Tu primera experiencia con Node.js

1

¿Dónde aprender backend con Node.js actualizado?

2

Todo lo que aprenderás sobre backend con Node.js

3

¿Qué es Node.js?

4

¿Qué es Node.js y para qué sirve?

5

Diferencias entre Node.js y JavaScript

6

Resumen: Diferencias Nodejs y Javascript

7

Instalación de Node.js

8

Arquitectura orientada a eventos

9

Node.js para la web

Manejo y uso de Streams con Node.js

10

Introducción a streams

11

Readable y Writable streams

12

Duplex y Transforms streams

Uso de utilidades de Node.js

13

Sistema operativo y sistema de archivos

14

Administrar directorios y archivos

15

Consola, utilidades y debugging

16

Clusters y procesos hijos

Crea tu primer proyecto en Express.js

17

¿Qué es Express.js y para qué sirve?

18

Creando tu primer servidor con Express.js

19

Request y Response Objects

Aprende a crear un API con REST

20

Anatomía de una API Restful

21

Estructura de una película con Moockaru

22

Implementando un CRUD en Express.js

23

Métodos idempotentes del CRUD

24

Implementando una capa de servicios

Cómo conectarse con librerías externas en Express.js

25

Creación de una BD en MongoAtlas

26

Conexión a MongoAtlas una instancia de MongoDB

27

Conexión con Robot3T y MongoDB Compass a una BD

28

Implementación de las acciones de MongoDB

29

Conexión de nuestros servicios con MongoDB

Conoce como funcionan los Middleware en Express.js

30

¿Qué es un middleware? Capa de manejo de errores usando un middleware

31

Manejo de errores asíncronos y síncronos en Express

32

Capa de validación de datos usando un middleware

33

¿Qué es Joi y Boom?

34

Implementando Boom

35

Implementando Joi

36

Probar la validación de nuestros endpoints

37

Middlewares populares en Express.js

Implementa tests en Node.js

38

Creación de tests para nuestros endpoints

39

Creación de tests para nuestros servicios

40

Creación de tests para nuestras utilidades

41

Agregando un comando para coverage

42

Debugging e inspect

Despliega tu primera aplicación en Express.js

43

Considerando las mejores prácticas para el despliegue

44

Variables de entorno, CORS y HTTPS

45

¿Cómo implementar una capa de manejo de caché?

46

¿Cómo contener tu aplicación en Docker?

47

Despliegue en Now

Conclusiones

48

¿Qué aprendiste en este curso?

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Node.js para la web

9/48
Recursos

Aportes 232

Preguntas 9

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Con la libreria momentjs

body = Buffer.concat(body).toString();
let fecha = moment(body, "DD/MM/YYYY");
let dia = fecha.format("dddd");
res.end(dia);
const http = require("http");
const moment = require("moment");

const server = http.createServer();

server.on("request", (req, res) => {
  if (req.method === "POST" && req.url == "/echo") {
    let body = [];
    req
      .on("data", chunk => {
        body.push(chunk);
      })
      .on("end", () => {
        res.writeHead(200, { "Content-type": "text/plain" });
        body = Buffer.concat(body).toString();
        if (!moment(body, "YYYY-MM-DD").isValid()) {
          res.end("no es un formato valido. Formato esperado YYYY-MM-DD");
        } else {
          var weekDayName = moment(body).format("dddd");

          res.end("Tu dia de Nacimiento es:" + weekDayName);
        }
      });
  } else {
    res.statusCode = 404;
    res.end();
  }
});

server.listen(8002);
console.log("Servidor enla url http://localhost:8002");

Utilizando el Modulo Moment

// El modulo moment es genial
const moment = require('moment');
let fecha = moment(body);
res.end(fecha.format('dddd')); // el formato 'dddd' es para que solo muestre el dia en texto.

Mi aporte

const http = require('http');
const server = http.createServer();

server.on('request', (req, res) => {
    let birthday = [];

    req.on('data', chunk => birthday.push(chunk.toString()));
    req.on('end', () => {
        res.writeHead(200, {'Content-Type': 'text/plain'});
        res.end(`Tu día de nacimiento es: ${getDayOfBirthday(birthday)}`);
    })

});

function getDayOfBirthday(date) {
    const days = ['Lunes', 'Martes', 'Miercoles', 'Jueves', 'Viernes', 'Sabado', 'Domingo'];
    const birthday = new Date(date);
    return days[birthday.getDay()]
}

server.listen(8001);

console.log('Servidor en la url http://localhost:8001')

Pues acá está mi servidor que valida una fecha

const http = require('http');
const server = http.createServer();

server.on('request',(req,res)=>{
    if(req.method === 'POST' && req.url=='/'){
        let body=[];
        const days=['Domingo','Lunes','Martes','Miércoles','Jueves','Viernes','Sábado'];
        const months = ['enero','febrero','marzo','abril','mayo','junio','julio','agosto','septiembre','octubre','noviembre','diciembre'];

        req.on('data', (chunk)=>{
            body.push(chunk);
        })
        .on('end',()=>{
            res.writeHead(200,{'Content-Type':'text/plain'})
            body=Buffer.concat(body).toString();
            const birthday=new Date(body)
            if(birthday.getFullYear()){
                res.end(`Naciste un ${days[birthday.getDay()]}, ${birthday.getDate()+1} de ${months[birthday.getMonth()]} de ${birthday.getFullYear()}`);
            }else{
                res.end(`Inserta una fecha correcta con el formato YYYY-MM-DD`)
            }
        })

    }else{
        res.statusCode=404;
        res.end();
    }
})

server.listen(8000);
console.log('servidor en la url http://localhost:8000')```

Solución a mi reto:

//formato de fecha de entrada: opcion 1: 10-16-2019, opcion2: 2019/10/16
const http = require('http');
const server = http.createServer();

const weekday = new Array(7);
weekday[0] = "Domingo";
weekday[1] = "Lunes";
weekday[2] = "Martes";
weekday[3] = "Miercoles";
weekday[4] = "Jueves";
weekday[5] = "Viernes";
weekday[6] = "Sabado";

server.on('request', (req, res)=> {
  if(req.method == 'POST' && req.url === '/birthday'){
    let body = []
    req.on('data', chunk => {
      body.push(chunk)
    })
    .on('end', () => {
      res.writeHead(200, {'Content-Type': 'text/plain'})
      let dayOfBirth = new Date(body)
      console.log(weekday[dayOfBirth.getDay()])
      body = Buffer.concat(body).toString()
      res.end(body)
    })
  }else{
    res.statusCode = 404
    res.end()
  }
})

server.listen(8001)
console.log('servidor en la url: http://localhost:8001')```

🤓

const http = require('http');
const server = http.createServer();

const semana = ['Domingo', 'Lunes', 'Martes', 'Miercoles', 'Jueves', 'Viernes', 'Sabado'];
        
server.on('request', (req, res) => {
    if (req.method === 'POST' && req.url == '/adivinarDia') {  
        let body = [];
        
        req.on('data', chunk => {
            body.push(chunk);
        })
        .on('end', () => {            
            body = Buffer.concat(body).toString();
            const date = new Date(body);
            let diaSemana = semana[date.getDay()];

            res.writeHead(200, {"Content-type": "text-plain"});
            res.end(`El dia de mi nacimiento fue un ${diaSemana}`);
        })
    }
    else {
        res.status = 404;
        res.end();
    }
})
const PORT = 3003;

server.listen(PORT, () => {
    console.log(`Eschuchando en el puerto ${PORT}`)
});

El challenge me quedo de la siguiente manera, ya que no encontre el como darle formato al input que requiere Date.getDay(), y asi obtener el dia en menos lineas de codigo.

Les comparto mi reto, tuve que modificar un poco para que se vea bien en los aportes de platzi, pueden utilizarlo de referencia, espero les ayude 😃

//obtain http module for create the server
const http = require('http')
//create the server and assign to const
const server = http.createServer()

const isValidMethod = (req, method) => {
  return req.method === method ? true : false
}

const isValidUrl = (req, url) => {
  return req.url == url ? true : false
}

const getWeekDay = date => {
  const weekDays = [
    'Sunday',
    'Monday',
    'Tuesday',
    'Wednesday',
    'Thursday',
    'Friday',
    'Saturday'
  ]
  const message = 'Your were born on'
  return `${message} ${weekDays[date.getDay()]}`
}

//handle events
server.on('request', (request, response) => {
  const okMethod = isValidMethod(request, 'POST')
  const okUrl = isValidUrl(request, '/challenge')
  const content = { 'Content-Type': 'text/plain' }
  if (okMethod && okUrl) {
    let body = new Array()
    //handle data
    request
      .on('data', chunk => {
        /*chunk is the data that we sent 
         in the request*/
        body.push(chunk)
      })
      .on('end', () => {
        //now body contains your birth date
        body = Buffer.concat(body).toString()
        let birthDate = new Date(body)
        response.writeHeader(200, content)
        response.end(getWeekDay(birthDate))
      })
  } else {
    response.writeHeader(400, content)
    response.end('404 not found :C')
  }
})

server.listen(8002)
console.log('running on http://localhost:8002/challenge')
/*
in posttman try with your birthdate
like yyyy mm dd
1994 12 09
*/
const http = require('http');
const server = http.createServer();
const days = ['Domingo', 'Lunes', 'Martes', 'Miercoles', 'Jueves', 'Viernes', 'Sabado'
];

const getDayName = function (chunk) {
  if ( Date.parse(chunk) ) {
    let date = new Date (chunk);
    let dayNumber = date.getDay();
    return days[dayNumber];
  } else {
    return 'El formato de fecha no concuerda, intenta nuevamente.';
  }
}

server.on('request', (req, res) => {
  if (req.method === 'POST') {
    let body = [];

    req.on('data', chunk => {
      let dayName = getDayName(chunk);
      body.push(dayName);
    })
    .on('end', () => {
      res.writeHead(200, {'Content-Type' : 'text-plain'});

      res.end(body.toString());
    });
  };
});

server.listen(8003);
console.log('Cumpleserver en la url http://localhost:8003')```

Comparto mi tarea realizada!

Va mi solución.

/**
 * Este servidor echo, tiene como finalidad recibir datos (fecha de nacimiento) mediante POST
 * y responder con el nombre del día que le corresponde a dicha fecha
 */
const http = require("http");
const server = http.createServer();

server.on("request", (req, res) => {
  if (req.method === "POST" && req.url === "/birthday") {
    let birthday = [];
    req
      .on("data", chunk => {
        birthday.push(chunk);
      })
      .on("end", () => {
        res.writeHeader(200, { "Content-type": "text/plain" });
        birthday = Buffer.concat(birthday).toString();
        const day = getDayBirth(birthday);
        res.end(`Tu naciste un día ${day}`);
      });
  }
});

server.listen(3000, () => {
  console.log("Servidor escuchando en http://localhost:3000");
});

function getDayBirth(birthday) {
  // Tomando como base que la fecha me llega en YYYY-mm-dd
  const data = birthday.split("-");
  // Construir una fecha valida. el mes 0 es Enero
  const newdate = new Date(
    Number(data[0]),
    Number(data[1]) - 1,
    Number(data[2])
  );

  switch (newdate.getDay()) {
    case 0:
      return "Domingo";
    case 1:
      return "Lunes";
    case 2:
      return "Martes";
    case 3:
      return "Miércoles";
    case 4:
      return "Jueves";
    case 5:
      return "Viernes";
    case 6:
      return "Sábado";
  }
}
const http = require('http');
const server = http.createServer();

server.on("request", (req, res) => {
    if (req.method === 'POST' && req.url == "/echo") {
        let body = [];

        req
            .on('data', chunck => {
                body.push(chunck)
            })
            .on('end', () => {
                res
                    .writeHead(200, 'Content-Type', 'text/plain');

                body = Buffer
                    .concat(body)
                    .toString()
                    .split('-');

                res
                    .end(returnDayOfWeekend(body));
            })
    } else {
        res.statusCode = 404;
        res.end();
    }

});

function returnDayOfWeekend(date) {

    date = new Date(date[0], date[1] - 1, date[2]);
    let day = '';

    switch (String(date.getDay())) {
        case '0': day = 'Domingo'
        break;
        case '1': day = 'Lunes'
        break;
        case '2': day = 'Martes'
        break;
        case '3': day = 'Miercoles'
        break;
        case '4': day = 'Jueves'
        break;
        case '5': day = 'Viernes'
        break;
        case '6': day = 'Sabado'
        break;
    }

    return `El dia de tu cumpleaños es el dia ${day}`;
}

const PORT = '8001'
server.listen(PORT);
console.log(`Servidor iniciado en la url http://localhost:${PORT}`);

const http = require('http');
const server = http.createServer();

server.on('request', (req, res) => {
    if (req.method == 'POST' && req.url === '/edad') {
        let body = [];
        let semana = ['Lunes', 'Martes', 'Miercoles', 'Jueves', 'Viernes', 'Sabado', 'Domingo'];
        req
          .on('data', chunck => {
            body.push(chunck);
        })
          .on('end', () => {
            res.writeHeader(200, { "Content-Type": "text/plain" });
            let edad = new Date(body);
            edad = semana[edad.getDay()];
            res.end('Naciste el día ' + edad);
        });     
    } else {
        res.statusCode = 404;
        res.end();
    }
});

server.listen(3001);
console.log('Servidor en la url http://localhost:3001');

💪💻 Estoy en busca de los MEJORES DEVELOPERS de LATAM:
🤘 ¿Eres un Master Pro, Senior Developer en: TypeScript, Node.js, Scrapping, end-2-end browser Jira?
Queremos conocerte en: https://selectalatam.teamtailor.com/jobs/preview/477fb8a9-1a9b-45f3-926a-22356e6a0558

🤘 ¿Tu especialidad es: Node y MySql Tecnologías secundarias: GraphQl?
Aplica ahora en: https://selectalatam.teamtailor.com/jobs/preview/8a2dea22-6f7c-4cc7-8540-7c07119bad11
🤘 ¿Tu gran amor es: Golang, Linux, Cloud Development, Java, C++ , JIRA?
Te esperamos en: https://selectalatam.teamtailor.com/jobs/preview/b833d966-6563-4ad0-9970-28715a4388cf

Es frustrante esforzarte en completar los retos y cuando quieres compartir tus resultados. La página no acepta tus comentarios porque “Tu comentario contiene enlaces a sitios no seguros”… Ojalá puedan mejorar eso. Uno sólo quiere compartir su código.

En “Archivos y Enlaces”, cuando se preciona Descargar todo. No se descargan los archivos de la clase.

<'use strict'

const http = require('http')
const server = http.createServer();

server.on('request', (req,res) => {
    if (req.method === 'POST' && req.url == "/echo"){
        let body = []
        let day, month, year;
        let birthday

        req.on('data', chunk => {
            body.push(chunk)
        })
        .on('end', () => {
            res.writeHead(200, {'Content-Type': 'text/plain'})
            body = Buffer.concat(body).toString().split(' ');
            day= body[0]
            month = body[1] - 1;
            year = body[2]
            birthday = new Date(year,month,day)
            birthday = birthday.toString();
            console.log(birthday);
            res.end(birthday)
        })
    } else {
        res.statusCode = 404
        res.end();
    }
})

server.listen(8001)
console.log('Servidor en la url http://localhost:8001');>

const http = require("http");
const server = http.createServer();

server.on("request", (req, res) => {
    if (req.method === "POST" && req.url == "/echo") {
        let body = [];

        req
            .on("data", chunk => {
                body.push(chunk);
            })
            .on("end", () => {
                res.writeHead(200, { "Content-Type": "text/plain" });
                body = Buffer.concat(body).toString();

                let day = new Date(body).getDay();
                console.log(day)
                let res_day = ["Sunday", "Monday", "Tuesday", , "Wednesday", "Thuesday", "Fryday", "Saturday"];
                console.log(res_day[day])


                res.end(res_day[day]);
            });
    } else {
        res.statusCode = 404;
        res.end();
    }
});

server.listen(8000);
console.log("Servidor en la url http://localhost:8000");
const http = require('http')
const server = http.createServer()

server.on('request', (req, res) => {
    if (req.method == 'POST' && req.url == "/echo"){
        let body = []

        req.on('data', chunk =>{
            body.push(chunk)
        })

        .on('end', () => {
            res.writeHead(200, {'Content-Type': 'text/plain'})
            body = Buffer.concat(body).toString()
            fecha = body.split(" ")

            year = fecha[0]
            month = fecha[1]
            day= fecha[2]

            birthday = new Date(year, month, day)
            weekday = birthday.getDay() // dia de la semana
            console.log(weekday)

            res.end(weekday.toString())
        })
    }else {
        res.statusCode = 404
        res.end()
    }
})

server.listen(8002)
console.log('servidor en la url http://localhost:8002')```

Mi reto

onst http = require('http')
const server = http.createServer()

const getDayFromDate = data => {
    var d = new Date(data)
    var dd = d.getDay()
    const dayNames = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"]
    return dayNames[dd - 1]
}

server.on('request', (req, res) => {
    if (req.method === 'POST' && req.url == '/birthday') {
        let body = []
        req
            .on('data', chunk => {
                body.push(chunk)
            })
            .on('end', () => {
                res.writeHead(200, { 'Content-Type': 'text/plan' })
                body = Buffer.concat(body).toString()
                var dayName = getDayFromDate(body)
                res.end(`Tu naciste el dia ${dayName}`)
            })
    } else {
        res.statusCode = 404
        res.end()
    }
})

server.listen(8001)
console.log('Servidor en http://localhost:8001')```

Mi solucion

const http = require("http");
const server = http.createServer();

server.on("request", (req, res) => {
  if (req.method === "POST") {
    let body = [];
    req
      .on("data", chunk => {
        body.push(chunk);
      })
      .on("end", () => {
        res.writeHead(200, { "Content-Type": "text/plain" });
        body = Buffer.concat(body).toString();
        let dateBirth = new Date(body).getDay();

        let week = [
          "Domingo",
          "Lunes",
          "Martes",
          "Miércoles",
          "Jueves",
          "Viernes",
          "Sábado"
        ];

        dateBirth = week[dateBirth];

        res.end(`Naciste un ${dateBirth}`);
      });
  } else {
    res.statusCode = 404;
    res.end("404");
  }
});

server.listen(8001);
console.log("Servidor en la url http://localhost:8001");

Les dejo mi solución al reto, una va con los comentarios que me sirvieron para resolverlo y la otra imagen solo el código.

Sin comentarios

Con comentarios

Mi solución:

const http = require('http');
const server = http.createServer();
const weekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Fryday', 'Saturday']

server.on('request', (req, res) => {
    if (req.method === 'POST' && req.url == '/echo') {

        let body = [];
        req.on('data', chunk => {
            body.push(chunk)
        })
        .on('end', () => {
            res.writeHead(200, { 'Content-Type': 'text/plain' });

            let dateBday = new Date(body);

            body = Buffer.concat(body).toString();
            res.end(`You were born on an ${weekdays[dateBday.getDay()]}`);
        })
    }
    else {
        res.statusCode = 404;
        res.end();
    }
})

server.listen(8010);
console.log('Servidor en la URL http://localhost:8010');

Hola les comparto mi solucion:

const http = require('http');
const server = http.createServer();
const port = 8001;
const url = 'http://localhost:';
const weekdays =[
  'Domingo',
  'Lunes',
  'Martes',
  'Miércoles',
  'Jueves',
  'Viernes',
  'Sábado'
]


server.on('request', (req, res) => {
	if (req.method === 'POST' && req.url === '/brithDay') {
		let body = [];
		req.on('data', chunk => {
			body.push(chunk);
		}).on('end', () => {
      res.writeHead(200, { 'Content-Type': 'text/plain' });
      let weekday = new Date (body).getDay()
			body = Buffer.concat(body).toString();
			res.end(`si naciste el ${body} naciste el dia ${weekdays[weekday]}`);
		});
	} else {
		res.statusCode = 404;
		res.end();
  }
  
});

server.listen(port);
console.log(`servidor en la url ${url}${port}`);

Mi solución al reto de la clase:

// Importamos http y creamos el servidor
const http = require('http');
const server = http.createServer();

// Función para obtener el día de la semana a partir de una fecha
const getWeekDay = (date) => {
  const weekDays = [
    'Domingo',
    'Lunes',
    'Martes',
    'Miércoles',
    'Jueves',
    'Viernes',
    'Sábado',
  ];

  return date instanceof Date && !isNaN(date)
    ? weekDays[date.getDay()]
    : 'Fecha inválida';
};

// Procesamos el request
server.on('request', (req, res) => {
  if (req.method === 'POST' && req.url == '/echo') {
    let body = [];
    req
      .on('data', (chunk) => {
        body.push(chunk);
      })
      .on('end', () => {
        res.writeHead(200, { 'Content-Type': 'text/plain' });
        body = Buffer.concat(body).toString();
        // Utilizamos la función creando una instancia de Date
        body = getWeekDay(new Date(body));
        res.end(body);
      });
  } else {
    res.statusCode = 404;
    res.end();
  }
});

server.listen(8001);
console.log('Servidor en la url http://localhost:8001');

me da como cosita enseñar mi codigo luego de ver que los demas tienen su solucion con menos codigo, pero aqui esta XD

PD: esa formula es del ‘Algoritmo de Zeller’, si quieren hacer pruebas y eso

const http = require("http");
const server = http.createServer();

server.on('request', (req,res)=>{
    if(req.method === 'POST' && req.url == "/echo"){
        let body = [];
        req.on("data", chunck =>{
            body.push(chunck)
        }).on("end",()=>{
            res.writeHead(200, {'content-type': 'text/plain'})

            var dayBorn = fechaNacimiento(Buffer.concat(body).toString());
            res.end(dayBorn)
        }) 
    }else{
        res.statusCode = 404
        res.end()
    }
})

server.listen(8000, ()=>{
    console.log("running in http://localhost:8000");
})

function fechaNacimiento(data){
    var parts = data.split('-');
    //var mydate = new Date(parts[2], parts[1] - 1, parts[0]);

    var year = parseInt(parts[2]); 
    var month = parseInt(parts[1]); 
    var day = parseInt(parts[0]); 

    if(month <= 2){
        month += 2
        year -= 1
    }else{
        month -= 2
    }
    var a = year % 100;
    var b = year / 100;
    var dayBorn = ( 700 +
        (month*26-2)/10 +
        day +
        a +
        a / 4 + 
        b / 4 - 
        b * 2
      ) % 7

    console.log(dayBorn)
    dayBorn = parseInt(dayBorn)
    switch(dayBorn){
        case 0: 
            dayBorn = "domingo"
            break 
        case 1: 
            dayBorn = "lunes"
            break 
        case 2: 
            dayBorn = "martes"
            break 
        case 3: 
            dayBorn = "miercoles"
            break 
        case 4: 
            dayBorn = "jueves"
            break 
        case 5: 
            dayBorn = "viernes"
            break 
        case 6: 
            dayBorn = "sabado"
            break 
    }

    console.log("dia=" + dayBorn)
    return dayBorn
}```

CHALLENGE No.1

CODE


POSTMAN

const http = require('http')
const server = http.createServer()
const dia = [
    'Domingo',
    'Lunes',
    'Martes',
    'Miercoles',
    'Jueves',
    'Viernes',
    'Sabado'
]
server.on('request', (req, res) => {
    if (req.method === 'POST' && req.url == '/time') {
        let fecha = []
        req.on('data', (chunk) => {
            fecha.push(chunk)
        })
        req.on('end', () => {

            res.writeHead(200, { 'content-type': 'text/plain' })
            fecha = Buffer.concat(fecha).toString()
            const cumple = new Date(fecha);
            let diaCumple

            if (!isNaN(cumple) && typeof cumple === 'object') {
                diaCumple = dia[cumple.getDay()]
            } else {
                diaCumple = 'Fecha inexistente'
            }
            res.end(diaCumple)
        })
    } else {
        res.statusCode = 404
        res.end()
    }
})

server.listen(8080)

console.log('servidor en linea');
const http = require("http")
const server = http.createServer();

const days = ["Domingo","Lunes","Martes","Miércoles","Jueves","Viernes","Sábado"]
function DiaNacimiento(date){
    let fecha = new Date(date)
    let dia = fecha.getDate()
    return ` El día de tu nacimiento fue: ${days[dia]}`
}
server.on("request",(req,res)=>{
    if(req.method =="POST" && req.url=="/edad"){
        let body = [];
        req
            .on("data", chunk =>{
            body.push(chunk)
        })
            .on("end",()=>{
                res.writeHead(200,{"Content-Type":"text/plain" })
                body = Buffer.concat(body).toString()
                let nacimiento = DiaNacimiento(body)
                res.end(nacimiento)
            })
    }else{
        res.statusCode = 404;
        res.end()
    }
})

server.listen(8000)
console.log("Sevidor en http://localhost/8000")

Mi solución utilizando Date();

// Crear un servidor que reciba tu fecha de cumpleaños y devuelva el día de la semana que nacieron.

const http = require('http');
const server = http.createServer();

server.on('request', (req, res) => {
    if (req.method === 'POST' && req.url == '/birthday') {
        let body = [];

        req.on('data', chunk => {
                body.push(chunk);
            })
            .on('end', () => {
                res.writeHeader(200, { 'Content-Type': 'text/plain' });
                body = Buffer.concat(body).toString();
                res.end(`Naciste un: ${getDayDate(body)}`);
            })
    } else {
        res.statusCode = 404;
        res.end();
    }
});

function getDayDate(data) {
    let date = new Date(data);
    let birthday = date.getUTCDay();
    switch (birthday) {
        case 0:
            birthday = 'Domingo';
            break;
        case 1:
            birthday = 'Lunes';
            break;
        case 2:
            birthday = 'Martes';
            break;
        case 3:
            birthday = 'Miercoles';
            break;
        case 4:
            birthday = 'Jueves';
            break;
        case 5:
            birthday = 'Viernes';
            break;
        case 6:
            birthday = 'Sabado';
            break;
        default:
            birthday = 'No es un día de la semana';
            break;
    }
    return birthday;
}

server.listen(3001);
console.log('Servidor local en la url http://localhost:3001');

Aqui mi implementacion.
Lo ideal seria evaluar formato de entrada entre otras cosas (Mejorara en un futuro)

const daysOfWeek = ["Domingo", "Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado"];

function getDate(dateIn){
    let date = new Date(dateIn);
    return date.getUTCDay();
}

const http = require("http");

const host = "127.0.0.1";

const port = 3000;

const server = http.createServer();

server.on("request", (req,res) =>{
    if (req.method == "POST" && req.url == "/birth"){
        let body = [];

        req.on("data",chunk=>{
            body.push(chunk);
        }).on("end", () =>{
            res.writeHead(200, {"Content-type": "text/plain"});
            body = Buffer.concat(body).toString();
            let day = daysOfWeek[getDate(body)];
            res.end("Naciste un "+day);
        })
    } else{
        res.statusCode = 404;
        res.end();
    }
})


server.listen(port, host, () =>{
    console.log(`Server runing at http://${host}:${port}/`);
})

NOTA: Importante validar que la fecha sea válida.

const http = require('http');
const server = http.createServer();
const moment = require('moment');


server.on('request', (req, res) => {
    if (req.method === 'POST' && req.url == '/echo') {
        let fecha = [];
        let respuesta = '';

        req.on('data', chunk => {
            fecha.push(chunk);
        }).on('end', () => {
            if(!moment(fecha).isValid())
            {
                respuesta = 'No es una fecha valida';
            }else{
                respuesta = moment(fecha).locale('es').format('dddd');
            }
            res.writeHead(200, { 'Content-Type': 'text/plain' })
            res.end(respuesta);
        })
    }
    else {
        res.statusCode = 404;
        res.end();
    }
});

server.listen(8001);
console.log('Servidor ejecutandose en el puerto: 8001')
const http = require('http');
const server = http.createServer();
const days = ['Domingo', 'Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado'];

server.on('request', (req, res) => {
	

	if (req.method == 'POST' && req.url == '/echo') {
		let body = [];

		req.on('data', chunk => {	// Se manda llamar cuando recibimos datos
			// body.push(chunk);		// Los chunks son pequeñas partes de datos
			const weekDay = new Date(chunk).getDay();
			body.push(days[weekDay])	// El dato a enviar será del tipo "August 29 1997"
		})
		.on('end', () => {
			res.writeHead(200, {'Content-Type': 'text/plain'});
			//body = Buffer.concat(body).toString();
			res.end(`Naciste un ${body}`);
		});
	} else {
		res.statusCode = 404;
		res.end();
	}
});

server.listen(8001);
console.log('Servidor en la url http://localhost:8001');

Listo!

const http = require("http");
const server = http.createServer();
const dias = ["Lunes", "Martes", "Miercoles", "Jueves", "Viernes"];

server.on("request", (req, res) => {
  if (req.method === "POST" && req.url == "/cumple") {
    let body = [];
    req
      .on("data", (chunk) => {
        body.push(chunk);
      })
      .on("end", () => {
        res.writeHead(200, { "Content-Type": "text/plain" });
        body = Buffer.concat(body).toString();
        var fecha = body.split("/", 3);
        const a = `Naciste un: ${
          dias[new Date(fecha[0], fecha[1], fecha[2]).getDay()]
        }`;
        res.end(a);
      });
  } else {
    res.statusCode = 404;
    res.end();
  }
});

server.listen(8001);

Me costó un poco y aún no sé como podría hacer para validar que sea el formato JSON el que se envíe (para que se convierta con el método JSON.parse() ), supongo que habría que manejar errores para que no se crashee el programa…

const http = require('http')
const server = http.createServer()

server.on('request', (req, res) => {
  if (req.method === 'POST' && req.url == '/echo') {
    let data = []
    const days = ['Domingo', 'Lunes', 'Martes',
      'Miercoles', 'Jueves', 'Viernes', 'Sábado'] // domingo es el primer día según MDN

    req
      .on('data', chunk => {
        data.push((chunk))
        data = Buffer.concat(data).toString() //convierte en String
        data = JSON.parse(data)//convierte a JSON
      })
      .on('end', () => {
        let { day, month, year } = data //desestructura el JSON
        date = new Date(`${month}/${day}/${year}`) //crea una fecha a partir de los datos desestructurados
        if (date == 'Invalid Date') { // si la fecha está mal escrita
          res.writeHead(400, { 'Content-type': 'text/plain' }) //envía Bad Request
          res.end('la fecha que ingresaste no es válida. Revisa que los datos sean correctos')
          console.log('Datos inválidos')
        } else {
          formatDate = `${day}/${month}/${year}` // formatea a los datos para devolver DD/MM/YYYY
          res.writeHead(200, { 'Content-type': 'text/plain' })
          res.end(`Naciste el ${formatDate} un día ${days[date.getDay()]}`) // el método getDay() devuelve un número entre 0-6 (7 días)
          console.log('Todo bien')
        }
      })
  } else {
    res.statusCode = 404
    res.end('Error 404: Not Found')
  }
})

server.listen(8000)
console.log('Servidor escuchando en http://localhost:8000')

Datos enviados:

{
	"month": 10,
	"day": 15,
	"year": 1995
}

Recibido:

Naciste el 15/10/1995 un día Domingo
Envio: yyyy/mm/dd.

const http = require('http');
const server = http.createServer();

server.on('request', (req, res) => {
    if (req.method === 'POST' && req.url === '/echo') {
        let body = [];

        req
            .on("data", chunk => {
                body.push(chunk);
            })
            .on("end", () => {
                res.writeHead(200, { "Content-Type": "text/plain" });
                body = Buffer.concat(body).toString();
                let days = ['Domingo', 'Lunes', 'Martes', 'Miercoles', 'Jueves', 'Viernes', 'Sabado'];
                let date = new Date(body);
                let day = date.getDay();
                res.end(`Naciste el día ${day} - ${days[day]}, segun la fecha ${date}`);
            });
    } else {
        res.statusCode = 404;
        res.end();
    }
});

server.listen(8001);
console.log('Servidor en la url http://localhost:8001');

Mi aporte de 3 soluciones para el reto.

  1. Enviar la fecha por la URL
const http = require('http')
const server = http.createServer()

server.on('request', (req, res) => {
  if (req.method === 'POST') {
    res.writeHead(200, { 'Content-Type': 'text/plain' })
    const url = req.url
    const dateBody = url.substring(1, url.length).split('-')
    const birthday = getDate(dateBody[2], dateBody[1], dateBody[0])
    res.end(`You were born on ${getWeekday(birthday.getDay())}`)
  } else {
    res.statusCode = 404
    res.end()
  }
})

function getDate(year, month, day) {
  return new Date(year, month - 1, day)
}

function getWeekday(dayNumber) {
  const weekday = [
    'Sunday',
    'Monday',
    'Tuesday',
    'Wednesday',
    'Thursday',
    'Friday',
    'Saturday',
  ]
  return weekday[dayNumber]
}

server.listen(3001)

  1. Enviar la fecha por raw
const http = require('http')
const server = http.createServer()

server.on('request', (req, res) => {
  if (req.method === 'POST' && req.url == "/birthday") {
    let dateBody = []
    req
      .on("data", chunk => {
        dateBody.push(chunk)
      })
      .on("end", () => {
        res.writeHead(200, { 'Content-Type': 'text/plain' })
        dateBody = Buffer.concat(dateBody).toString().split('-')
        const birthday = getDate(dateBody[2], dateBody[1], dateBody[0])
        res.end(`You were born on ${getWeekday(birthday.getDay())}`)
      })
  } else {
    res.statusCode = 404
    res.end()
  }
})

function getDate(year, month, day) {
  return new Date(year, month - 1, day)
}

function getWeekday(dayNumber) {
  const weekday = [
    'Sunday',
    'Monday',
    'Tuesday',
    'Wednesday',
    'Thursday',
    'Friday',
    'Saturday',
  ]
  return weekday[dayNumber]
}

server.listen(3001)

  1. Usando Moment.js
const http = require('http')
const server = http.createServer()
const moment = require('moment')

server.on('request', (req, res) => {
  if (req.method === 'POST' && req.url == '/birthday') {
    let dateBody = []
    req
      .on('data', chunk => {
        dateBody.push(chunk)
      })
      .on('end', () => {
        res.writeHead(200, { 'Content-Type': 'text/plain' })
        dateBody = Buffer.concat(dateBody).toString()
        let birthday = moment(dateBody, 'DD/MM/YYYY')
        let day = birthday.format('dddd')
        res.end(`You were born on ${day}`)
      })
  } else {
    res.statusCode = 404
    res.end()
  }
})

server.listen(3001)

Excelente clase, y muy bien por darnos retos, eso nos ayuda a confirmar los conocimientos de Node.js que vamos adquiriendo.
Esta es mi soluición:

En lugar de usar Postman, utilizo una extensión de VSCode llamada ThunderClient que funciona de una manera similar pero sin la necesidad de cambiar de contexto.😁

Así quedó mi código después de resolver el reto

const moment = require('moment');
const http = require('http');
const server = http.createServer();

server.on('request', (req, res) =>{
    if (req.method === 'POST' && req.url == '/echo'){
        let body = [];


        req.on('data', chunk => {
            body.push(chunk);
        })
        .on('end', () =>{
            res.writeHead(200, {'Content-Type': 'text/plain'});
            body = Buffer.concat(body).toString();

            let fecha = moment(body);
            res.end(fecha.format('dddd')); // el formato 'dddd' es para que solo muestre el dia en texto.
            
        
        })
    } else {
        res.statusCode = 404;
        res.end();
    }
});


server.listen(7001);

En javascript los string heredan de los event emitter, es decir un readble string o string también tiene eventos

El objeto request es un readble string

¿Qué es el objeto request y que se puede hacer con el?

Aquí mi solución al reto:

Mi solución:

.on('end', () => {
      res.writeHead(200, {'Content-Type': 'text/plain'})
      body = Buffer.concat(body).toString()
      
      const myBirthday = new Date(body)
      const getDay = myBirthday.getDay() - 1
      const days = ['Lunes', 'Martes', 'Miercoles', 'Jueves', 'Viernes', 'Sabado', 'Domingo']
      res.end(days[getDay])
    })
   
  } else {
    res.statusCode = 404
    res.end()
  }

Para no tener problemas, solo puse
res.end(body.toString());

Aquí mi respuesta al reto:

const http = require("http");
const server = http.createServer();

let diasSemana =['Domingo','Lunes','Martes','Miercoles','Jueves','Viernes','Sabado'];

server.on("request", (req, res) => {
  if (req.method == "POST" && req.url == "/echo") {
    let body = [];

    req
      .on("data", (chunk) => {
        body.push(chunk);
      })
      .on("end", () => {
        res.writeHead(200, { "Content-Type": "text/plain" });
        body = Buffer.concat(body).toString();
        const dayWeek = new Date(body);
        let day = dayWeek.getDay();
        res.write('Indique su fecha de nacimiento en el siguiente formato MM/DD/AAAA:\n');
        res.end('Naciste el día '+diasSemana[day]);
      });
  } else {
    res.statusCode = 404;
    res.end("Lo lamento no encontre la pagina que buscas");
  }
});

server.listen(8002);

const moment = require("moment");
...

body = moment(Buffer.concat(body).toString()).format("dddd");
res.end(body);

Estuve dandole un rato, tambien estuve viendo los diferentes codigos en los comentarios. Aca mi codigo:

const http = require("http");
const server = http.createServer();
const Semana = [
  "Domingo",
  "Lunes",
  "Martes",
  "Miercoles",
  "Jueves",
  "Viernes",
  "Sabado",
];

server.on("request", (req, res) => {
  if (req.method === "POST" && req.url === "/echo") {
    let body = [];
    req
      .on("data", (chunk) => {
        body.push(chunk);
      })
      .on("end", () => {
        const date = new Date(body.toString());
        let diaSemana = Semana[date.getDay()];
        res.writeHead(200, { "Content-type": "text/plain" });
        res.end(`El dia de tu nacimiento fue ${diaSemana}`);
      });
  } else {
    res.statusCode = 404;
    res.end("Hubo un error");
  }
});

server.listen(8002);
console.log("Servidor corriendo en el puerto 8002");
const http = require('http');
const  calculateDate  = require('./functions');
const server = http.createServer();

server.on('request', (req,res)=> {
  if(req.method === 'POST' && req.url == "/echo"){
    let body = [];
    req.on("data", chunk => {
      body.push(chunk);
    })
    .on("end",() => {
      res.writeHead(200,('Content-Type', 'application/json'))
      body = Buffer.concat(body).toString();
      const response = JSON.parse(body);
      const arrDate = response.birthday.split('/');
      const resultDay = calculateDate(parseInt(arrDate[0]),parseInt(arrDate[1]),parseInt(arrDate[2]));
      res.end(JSON.stringify({'day':resultDay}));
    });
  }else{
    res.statusCode=404;
    res.end();
  }
  
})
server.listen(8002);

Mi función para calcular el día : ALGORITMO DE ZELLER

const weekdayNames = {
  1:'lunes',
  2:'Martes',
  3:'Miércoles',
  4:'Jueves',
  5:'Viernes',
  6:'Sábado',
  7:'Domingo',
}
function calculateDate (dd,mm,aaaa){
  const day = parseInt((14 - mm) / 12);
  const year = aaaa - day;
  const month = parseInt(mm + (12 * day) - 2);
  const dayResult = parseInt(dd + year + parseInt(year/4) - parseInt(year/100) + parseInt(year/400)+((31*month) / 12)) % 7;
return weekdayNames[dayResult];
}
module.exports = calculateDate;
```

Les comparto mi solución con date-fns:

const http = require('http')
const server = http.createServer()
const dateFns = require('date-fns')

server.on('request', (req, res) => {
  if (req.method === 'POST' && req.url === '/birthday') {
    const data = []

    req
      .on('data', chunk => {
        data.push(chunk)
      })
      .on('end', () => {
        const [year, month, day] = Buffer.concat(data).toString().split('-')

        try {
          if (month === 0)
            throw new Error()

          const birthday = dateFns.format(
            dateFns.subMonths(new Date(year, month, day), 1),
            'yyyy/MM/dd'
          )

          res.writeHead(200, { 'Content-Type': 'application/json' })
          res.end(
            JSON.stringify({
              error: false,
              message: `Your birthday is on ${birthday}`
            })
          )
        } catch (e) {
          res.writeHead(400, { 'Content-Type': 'application/json' })
          res.end(
            JSON.stringify({
              error: true,
              message: 'Wrong date format, try: "yyyy-MM-dd"'
            })
          )
        }
      })
  }
})

server.listen(1996, () => {
  console.log('Server running on port 1996')
})

Así me quedó con Luxon

const http = require('http');
const moment = require('moment');
const server = http.createServer();

// Send post request with birthday date (dd-mm-yyyy) and return day name

server.on('request', (req, res) => {
    // res.statusCode = 200;
    // res.setHeader('Content-Type', 'text/plain');

    if( req.method === 'POST' && req.url === '/echo'){

        let body = [];

        req.on('data', chunk => { // on data -> when recieve data
            body.push(chunk)
        })
        .on('end', () => {
            res.writeHead(200, { 'Content-Type': 'text/plain'})
            body = Buffer.concat(body).toString(); // body to string
            fecha = moment(body, "DD-MM-YYY").format('dddd');
            res.end(fecha);
        })
    } else {
        res.statusCode = 404;
        res.end
    }
})

server.listen(8001);


Yo acabo de hacer un proyecto usando este concepto usando handlebars

https://mysql-nodejs-crud.herokuapp.com/

tambien pueden seguirme en github si gustan:

https://github.com/who-Is-Beto

Con la api Date de EcmaScript

Usando moment js

const http = require('http')
const server = http.createServer()
const moment = require('moment')

server.on('request', (req, res) => {
  if (req.method === 'POST' && req.url == "/echo") {
    let body = []
    req.on('data', chunk => {
      body.push(chunk)
    })
    .on('end', () => {
      res.writeHead(200, {'Content-Type': 'text/plain'})
      body = Buffer.concat(body).toString()
      body = dateToWeekday(body)
      res.end(body)
    })
  } else {
    res.statusCode = 404
    res.end()
  }
})

function dateToWeekday(dateString) {
  if (moment(dateString).isValid()) {
    return moment(dateString).format('dddd') 
  } else {
    return 'Error en el formato de la fecha'
  }  
}

server.listen(8001)
console.log('Servidor en la url http....localhost:8001');

Resuelto el challenge con el módulo moment!!

Logre desarrollar el codigo de la clase, pero no se como hacer el reto 😦 alguien me podria dar una pista, lei en los comentarias que estan usando la clase Date y la funcion getDay()

dejo el codigo de la clase por si a alguien le sirve

const http = require('http');
const server = http.createServer();

server.on('request', (req, res) => {
    if(req.method === 'POST' && req.url == '/echo'){
        let body = []

        req
            .on('data', chunk => {
                body.push(chunk)
            })
            .on('end', () => {
                res.writeHead(200, {'Content-Type': 'text/plain'})
                body = Buffer.concat(body).toString()
                res.end(body)
            })
    }
    else{
        res.statusCode = 404
        res.end()
    }
});

server.listen(8000);
console.log('Servidor en la url https://localhost:8000')
const http =   require ('http');

const server = http.createServer();

server.on('request',(req, res) => {
    if (req.method === "POST" && req.url == "/dia-de-cumple") {
        let body = [];
        req.on('data', (fecha)=> {
            let cumple = new Date(fecha);
            const diaSemana = ['Domingo', 'Lunes', 'Martes', 'Miercoles', 'Jueves', 'Viernes', 'Sabado'];
            let diaCumple = `Dia de cumple es: ${diaSemana[cumple.getUTCDay()]}`;
            res.end(diaCumple);
        })
    } else {
        res.statusCode = 404;
        res.end();
    }
})

server.listen(8003);
const moment = require('moment');

calculateDay({
    year: 1992,
    month: 13,
    day: 23
}
);

function calculateDay(date) {
    const { year, month, day } = date;
    const days = ['Domingo', 'Lunes', 'Martes', 'Miercoles', 'Jueves', 'Viernes', 'Sabado'];
    const dayInt = moment(`${year}-${month}-${day}`).day();

    if (isNaN(dayInt)) {
        return 'Invalid Date';
    }

    return days[dayInt];
}

Enviando un JSON con la fecha de cumpleaños

const http = require('http');
const server = http.createServer();

server.on('request', (request, response) => {
    if(request.method === 'POST' && request.url == '/echo'){
        let body = [];

        request
            .on("data", chunk => {
                body.push(chunk);
            })
            .on("end", () => {
                // OJO en postman mandamos un objeto JSON de la siguiente forma: {"mes" : "08", "dia" : 27, "año" : 1992}
                response.writeHead(200, { "Content-Type": "text/plain" });
                let fechaCumpleaños = JSON.parse(Buffer.concat(body).toString());// Aquí parseamos el String del body a JSON
                response.end(fechaCumpleaños.dia.toString());// Del objeto fechaCumpleaños regresamos su atributo dia
            });
    }
    else{
        response.statusCode = 404;
        response.end();
    }
});

server.listen(8001);
console.log('Servidor en la url http://localhost:8001');

yeip

Aunque por ahora solo podría usar los formatos YYYYMMDD y YYYY-MM-DD al escribir en Postman

const http = require('http');
const moment = require('moment');
const server = http.createServer(); // se crea servidor

server.on('request', (req, res) => {
    if (req.method === 'POST' && req.url == "/echo") {
        let body = [];

        req
            .on("data", chunk => {
                body.push(chunk);
            })
            .on("end", () => {
                res.writeHead(200, { 'Content-Type': 'text/plain' });
                body = Buffer.concat(body).toString();
                console.log(body);
                let fechaNacimiento = body;
                res.end(moment(fechaNacimiento).format('dddd'));
            });
    } else {
        res.statusCode = 404;
        res.end();
    }

});


server.on('request', (req, res)=>{
    if (req.method === 'POST' && req.url == '/echo'){
        let body = [];
        req.on('data', chunk => {
            body.push(chunk);
        })
        .on('end', () =>{
            res.writeHead(200, {'Content-Type': 'text/plain'});
            let DayOfWeek = new Array(7);
            DayOfWeek[0]="Domingo";
            DayOfWeek[1]="Lunes";
            DayOfWeek[2]="Martes";
            DayOfWeek[3]="Miercoles";
            DayOfWeek[4]="Jueves";
            DayOfWeek[5]="Viernes";
            DayOfWeek[6]="Sabado";
            let day =  DayOfWeek[new Date(Buffer.concat(body).toString()).getDay()];
            
            res.end(day.toString());
        })
    }else {
        res.statusCode = 404;
        res.end();
    }

})

server.listen(8001);

Solución al reto según lo que entendí

const http = require('http');
const server = http.createServer();

class calculateDate {
    constructor(birthDate){
        this.data = birthDate.split('/');
    }
    paramA(data){
        if( data >= 2000 && data <= 2099 ){
            return 0;
        }else if( data >= 2100 && data <= 2199 ){
            return -2;
        }else if(data >= 2200 && data <= 2299){
            return -4;
        }else if( data >= 1900 && data <= 1999 ){
            return 1;
        }else if( data >= 1800 && data <= 1899 ){
            return 3;
        }else if( data >= 1700 && data <= 1799 ){
            return 5;
        }
    }
    paramB(data){
        data = data.toString();
        const lastTwoDigits = data[2] + data[3];
        const calculateParam = parseInt(lastTwoDigits);
        return Math.floor(calculateParam + calculateParam * 1 / 4);
    }
    paramC(data){
        data = parseInt(data);
        const yearBis = data % 4;
        if(yearBis === 0){
            return -1;
        }
        return 0;
    }
    paramD(data)
    {
        if( data == 'Enero' || data == '1' ){
            return 6;
        }else if( data == 'Febrero' || data == '2' ){
            return 2;
        }else if( data == 'Marzo' || data == '3' ){
            return 2;   
        }else if( data == 'Abril' || data == '4' ){
            return 5;
        }else if( data == 'Mayo' || data == '5' ){
            return 0;
        }else if( data == 'Junio' || data == '6' ){
            return 3;
        }else if( data == 'Julio' || data == '7' ){
            return 5;
        }else if( data == 'Agosto' || data == '8' ){
            return 1;  
        }else if( data == 'Septiembre' || data == '9' ){
            return 4;
        }else if( data == 'Octubre' || data == '10' ){
            return 6;           
        }else if( data == 'Noviembre' || data == '11' ){
            return 2;
        }else if( data == 'Diciembre' || data == '12' ){
            return 4;
        }
    }
    returnNameDay(data){
        switch (data) {
            case 0:
                return 'Domingo';
            case 1:
                return 'Lunes';
            case 2:
                return 'Martes';
            case 3:
                return 'Miercoles';
            case 4:
                return 'Jueves';
            case 5:
                return 'Viernes';
            case 6:
                return 'Sabado';
            default:
                break;
        }
    }
    calculateDate(){
        const data = this.data;
        const year = parseInt(data[2]);
        const month = data[1];
        const day = parseInt(data[0]);
        let sumResult = this.paramA(year) + this.paramB(year) + this.paramC(year) + this.paramD(month) + day;
        while( sumResult > 7 ){
            sumResult = sumResult - 7;
        }
        const nameDay = this.returnNameDay(sumResult)
        return nameDay;
    };
}



server.on('request', (req,res)=>{
    if( req.method === 'POST' && req.url == '/birth' ){
        let body = [];
        req.on('data', chunk =>{
            body.push(chunk);
        })
        .on('end', ()=>{
            res.writeHead(200, {'content-type': 'text/plain'});
            body = Buffer.concat(body).toString();
            //console.log(body);
            const dayOfDate = new calculateDate(body);
            const finalResult = `Ese dia fue ${dayOfDate.calculateDate()}`
            res.end(finalResult);
        });
    }else{
        res.statusCode = 404;
        res.end();
    }
});

server.listen(8002);
console.log('Servidor escuchando en 8002'); 
<code> 
const http = require('http')

const server = http.createServer()


server.on('request',(req,res) => {
    if(req.method === 'POST' && req.url ==='/echo' ){
        let body = []
        req.on('data', chunk => {
            body.push(chunk)
        })
        .on('end',() =>{
            res.writeHead(200,{'Content-type': 'text/plain'})
            body = Buffer.concat(body).toString()
            let dateArray = body.split('-')
            const finalDate = `Your born the day ${dateArray[0]} `
            res.end(finalDate)
        })
    }else{
        res.statusCode = 404
        res.end()
    }
})

server.listen(8001)


</code>

Para el reto:

const http = require('http');
const server = http.createServer();
const getDay = (dateInput) =>{
    let date = new Date(`${dateInput}`);
    const days = ['Sunday','Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
    return days[date.getDay()];
}

server.on('request', (req, res)=>{
    if(req.method === "POST" && req.url== "/echo"){
        let body = [];
        req.on('data', chunk =>{
            body.push(chunk);
        })
        .on('end', ()=>{
            res.writeHead(200, {"Content-Type": "text/plain"})
            body = Buffer.concat(body).toString()
            res.end(`${getDay(body)}`);
        })

    }else{
        res.statusCode = 404;
        res.end();
    }

});
server.listen(8001);

Propuse dos soluciones: Una con un arreglo (para tener listos los días de la semana; la otra, con Switch Case.

const http = require("http");
const server = http.createServer();

server.on("request", (req, res) => {
  if ((req.method = "POST" && req.url == "/cumple")) {
    let body = [];

    req
      .on("data", (chunk) => {
        body.push(chunk);
      })
      .on("end", () => {
        res.writeHead(200, { "Content-Type": "text/plain" });
        body = Buffer.concat(body).toString();
       
        let fecha = new Date(body);
        let day = fecha.getDay(); //Retorna el número del día. Si es 0 es domingo.
        
        let dayOfWeek = ['Domingo', 'Lunes', 'Martes', 'Miércoles', 'Jueves',  'Viernes', 'Sábado']; 

        let diaSemana;
        switch (day) {
          case 0:
            diaSemana = "Domingo";
            break;
          case 1:
            diaSemana = "Lunes";
            break;
          case 2:
            diaSemana = "Martes";
            break;
          case 3:
            diaSemana = "Miércoles";
            break;
          case 4:
            diaSemana = "Jueves";
            break;
          case 5:
            diaSemana = "Viernes";
          case 6:
            diaSemana = "Sábado";
            break;
        }

        res.end(`Tu día de nacimiento fue: ${diaSemana} // ${dayOfWeek[day]}`);
      });
  } else {
    res.statusCode = 404;
    res.end();
  }
});

server.listen(8001);
console.log("Servidor en la url http ://localhost:8001");

PD. Le tuve que agregar un espacio después de htttp, porque Platzi lo detecta como enlace a sitio no seguro.

// Importamos el módulo de http para crear el servidor web
const http = require('http');
// Creamos el servidor
const server = http.createServer();
// Definimos el puerto
const port = 8001;
// Recibimos las solicitudes con el evento "request"
// Usamos dos parametros "req" para gestionar la solicitud recibida y  "res" para definir la respusta que enviará el servidor
server.on('request', (req, res) => {
    // Evaluamos que la solicitud sea de tipo POST y que la url sea /echo 
    if (req.method === 'POST' && req.url === '/echo') {
        // definimos la variable body para recibir los datos enviados en la solicitud
        let body = [];
        // recibimos los datos y los dividimos en "chucks"
        req.on('data', chuck => {
            body.push(chuck);
        })
        // cuando termina de recibir los datos 
        .on('end', () => {
            // enviamos la respuesta positiva en texto plano
            res.writeHead(200, {'Content-Type' : 'text/plain'});
            // pasamos los datos en stream a tipo string utilizando el Buffer
            body = Buffer.concat(body).toString();
            // enviamos los datos recibidos como respuesta
            res.end(`Respuesta del servidor: ${body}`);
        });
    // si no recibimos un POST
    } else {
        // definimos el código de respuesta en 404 
        res.statusCode = 404;
        // cerramos la peticion
        res.end();
    }
});
// Asignamos el puerto en donde estara "escuchando" el servidor
server.listen(port);
// Mensaje en consola
console.log(`Servidor activo en el puerto ${port}`);

Tengo un error: alguien sabe que puede ser?

Calcula el día de la semana sin moment.js.

const http = require("http");

const server = http.createServer();

const calculateDate = (inputDate = "Oct 02, 1994") => {
  const days = {
    0: "Domingo",
    1: "Lunes",
    2: "Martes",
    3: "Miercoles",
    4: "Jueves",
    5: "Viernes",
    6: "Sabado",
  };
  const date = new Date(inputDate);
  const day = date.getDay();
  return days[day];
};

server.on("request", (req, res) => {
  const { method, url } = req;
  console.log(`Nueva request a url ${url} con metodo ${method}`);
  if (method === "POST" && url === "/calculate") {
    const body = [];
    req.on("data", (chunk) => {
      body.push(chunk);
    });
    req.on("end", () => {
      const parsedBody = Buffer.concat(body).toString();
      console.log("Body", parsedBody);
      res.writeHead(200, { "Content-Type": "text/plain" });
      const response = `Hola, naciste el día  ${calculateDate(
        parsedBody
      )} de acuerdo con tu fecha de cumpleaños que es ${parsedBody}`;
      res.write(response);
      res.end();
    });
  } else {
    res.statusCode = 404;
    res.end();
  }
});

server.listen(8001);

console.log("Escuchando en el puerto 8001");

Hola, les comparto mi codigo, en este caso use la libreria datejs para poder obtener el dia facilmente, y poder mostrar el dia como un string mediante un array

const http = require('http');
const date = require('datejs');
const server = http.createServer();


server.on('request', (req, res) => {
   if (req.method === 'POST' && req.url == '/echo') {
      let  body = [];
      req.on('data', chunk => {
         body.push(chunk);
      })
      req.on('end', () => {
         let days = ["lunes","martes","miercoles","jueves","viernes","sabado","domingo"];
         
         /*↓ Haciendo uso de la lireria "datejs" para obtener el dia de forma sencilla sin importart el año*/
         dateProvided = Buffer.concat(body).toString();
         dayNumber = Date.parse(dateProvided).getDay();
         dayOfBirth = days[dayNumber-1];
         
         res.writeHead(200,{'Content-Type': 'text/plain'});
         res.end(dayOfBirth);
      })

   } else {
      res.statusCode = 404;
      res.end();
   }


})

server.listen(8001);
console.log('Servidor ejecutandose en localhost:8001');

Entrada: dd/mm/aaaa por ejemplo 23/09/1998
Salida: Miércoles

const http = require("http");
const server = http.createServer();

server.on("request", (req, res) => {
  if (req.method === "POST" && req.url == "/echo") {
    let body = [];
    const days = [
      "Domingo",
      "Lunes",
      "Martes",
      "Miércoles",
      "Jueves",
      "Viernes",
      "Sábado",
    ];

    req
      .on("data", (chunk) => {
        body.push(chunk);
      })
      .on("end", () => {
        res.writeHead(200, { "Content-Type": "text/plain" });
        body = Buffer.concat(body).toString().split("/");

        const day = body[0];
        const month = body[1]-1;
        const year = body[2];
        const birthdate = new Date(year, month, day);

        res.end(days[birthdate.getDay().toString()]);
      });
  } else {
    res.statusCode = 404;
    res.end();
  }
});

server.listen(8001);

Reto completado, recibe los datos en formato JSON.
ej:

{
    "day": 21,
    "month": 6,
    "year": 2005
}

💗💜

Use el modulo momment

const http = require("http");
const server = http.createServer();
const moment = require("moment");

server.on("request", (req, res) => {
    if (req.method === "POST" && req.url === "/cumple") {
        let body = [];

        req.on("data", chunk => {
            body.push(chunk);
        }).on("end", () => {
            res.writeHead(200, { "Content-Type": "text/plain" })
            body = Buffer.concat(body).toString();
            let now = moment(`${body}`, "DD-MM-YYYY");
            res.end(now.format("dddd"));
        })
    } else {
        res.statusCode = 404;
        res.end();
    }
});

server.listen(3000, () => {
    console.log("Servidor en el puerto 3000");
});

Les comparto mi solucion, apoyada de la solucion del compañero Ojeda ^^

Aqui les dejo mi solucón al desafio!

![](https://carbon.now.sh/?bg=rgba(171%2C 184%2C 195%2C 1)&t=seti&wt=none&l=javascript&ds=true&dsyoff=20px&dsblur=68px&wc=true&wa=true&pv=56px&ph=56px&ln=false&fl=1&fm=Hack&fs=14px&lh=133%&si=false&es=2x&wm=false&code=const%20http%20%3D%20require(%22http%22)%3B%0Aconst%20server%20%3D%20http.createServer()%3B%0A%0Aserver.on(%22request%22%2C%20(req%2C%20res)%20%3D%3E%20%7B%0A%20%20if%20(req.method%20%3D%3D%3D%20%22POST%22%20%26%26%20req.url%20%3D%3D%3D%20%22%2Fecho%22)%20%7B%0A%20%20%20%20let%20body%20%3D%20%5B%5D%3B%0A%0A%20%20%20%20req%0A%20%20%20%20%20%20.on(%22data%22%2C%20(chunk)%20%3D%3E%20%7B%0A%20%20%20%20%20%20%20%20body.push(chunk)%3B%0A%20%20%20%20%20%20%7D)%250A%2520%2520%2520%2520%2520%2520.on(%2522end%2522%252C%2520()%2520%253D%253E%2520%257B%250A%2520%2520%2520%2520%2520%2520%2520%2520res.writeHead(200%252C%2520%257B%2520%2522Content-Type%2522%253A%2520%2522text%252Fplain%2522%2520%257D)%253B%250A%2520%2520%2520%2520%2520%2520%2520%2520body%2520%253D%2520Buffer.concat(body).toString().split(%2522%252F%2522)%253B%250A%250A%2520%2520%2520%2520%2520%2520%2520%2520const%2520date%2520%253D%2520new%2520Date(%2560%2524%257Bbody%255B2%255D%257D-%2524%257Bbody%255B1%255D%257D-%2524%257Bbody%255B0%255D%257D%252000%253A00%253A00%2560)%253B%250A%250A%2520%2520%2520%2520%2520%2520%2520%2520const%2520dayOfWeek%2520%253D%2520date.getDay()%253B%250A%250A%2520%2520%2520%2520%2520%2520%2520%2520let%2520dayNames%2520%253D%2520%255B%250A%2520%2520%2520%2520%2520%2520%2520%2520%2520%2520%2522Domingo%2522%252C%250A%2520%2520%2520%2520%2520%2520%2520%2520%2520%2520%2522Lunes%2522%252C%250A%2520%2520%2520%2520%2520%2520%2520%2520%2520%2520%2522Martes%2522%252C%250A%2520%2520%2520%2520%2520%2520%2520%2520%2520%2520%2522Miercoles%2522%252C%250A%2520%2520%2520%2520%2520%2520%2520%2520%2520%2520%2522Jueves%2522%252C%250A%2520%2520%2520%2520%2520%2520%2520%2520%2520%2520%2522Viernes%2522%252C%250A%2520%2520%2520%2520%2520%2520%2520%2520%2520%2520%2522Sabado%2522%252C%250A%2520%2520%2520%2520%2520%2520%2520%2520%255D%253B%250A%250A%2520%2520%2520%2520%2520%2520%2520%2520res.end(dayNames%255BdayOfWeek%255D)%253B%250A%2520%2520%2520%2520%2520%2520%257D)%253B%250A%2520%2520%257D%2520else%2520%257B%250A%2520%2520%2520%2520res.statusCode%2520%253D%2520404%253B%250A%2520%2520%2520%2520res.end()%253B%250A%2520%2520%257D%250A%257D)%253B%250A%250Aserver.listen(3001)%253B%250Aconsole.log(%2522Server%2520on%2520port%25203001%2522)%253B)

Buena clase

Mi solución. Nací un día miércoles , revisé y es verdad.
Puedes utilizar inputs como: YYYY-MM-DD, YYYY|MM|DD, YYYY/MM/DD
Aquí el código: https://gist.github.com/palafoxernesto/b6c37b17b0929b51c699e82682c3b1f0