Inicio del curso

1

¿Qué vamos a construir en el curso avanzado de Node.js?

Introducción a Node.js

2

Conoce qué es node.js

3

Características de la plataforma Node.js

4

¿Qué tipo de aplicaciones podemos desarrollar con Node.js?

Preparando el entorno de Desarrollo

5

Cómo instalar Node.js en macOS

6

Cómo instalar PostgreSQL y Redis en macOS

7

Cómo instalar Visual Studio Code en macOS

8

Cómo instalar Ansible en macOS

Arquitectura del Proyecto (Platziverse)

9

Arquitectura y Componentes del proyecto

Introducción a protocolos y patrones de aplicaciones en tiempo real

10

Cómo funciona el modelo Pub/Sub en MQTT y Web Sockets

Creando Módulo de Base de Datos (platziverse-db)

11

Estructura básica de un módulo de Node.js

12

Definición de entidades de base de datos

13

Implementación de modelos con sequelize

14

Implementación de un módulo básico de base de datos

15

Implementación de script de inicialización de base de datos

16

Creando una advertencia sobre el borrado de base de datos

17

Introducción a pruebas unitarias con Ava.js

18

Introducción a code coverage con nyc

19

Cómo hacer Mocks y Stubs con Sinon

20

Creación de fixtures y definición básica del servicio de Agent

21

Implementación de findbyId y pruebas en el servicio Agent

22

Implementación de createOrUpdate

23

Revisión del servicio Agent

24

Implementación del servicio Metric

25

Realizando un ejemplo con el módulo de base de datos

26

Reto: Cómo modificar el script de inicialización de la base de datos

Construyendo un servidor en tiempo real para Internet de las Cosas con Mosca/MQT

27

Definición de un Broker de Mensajería

28

Definición de los tipos de mensajes

29

Implementación del servidor MQTT

30

Cómo recibir mensajes

31

Cómo integrar el servidor MQTT con la base de datos

32

Cómo almacenar la información del agente y reportar el agente conectado

33

Cómo almacenar la información de las métricas

34

Probando el servidor MQTT (Ejemplo con mqtt client)

Construyendo el agente de monitoreo (platziverse-agent)

35

Cómo implementar un custom EventEmitter usando ES6 classes

36

Definiendo un timer de ejecución continua (setInterval)

37

Implementación del cliente MQTT

38

Implementación de métricas personalizadas

39

Probar agent (ejemplo)

Construyendo una API REST con Express (platziverse-api)

40

Implementación de un servidor básico con express

41

Definición de rutas del API

42

Implementación de manejo de errores con express

43

Pruebas básicas de Integración con Ava y supertest

44

Integración con el módulo de base de datos

45

Implementación de ruta del API

46

Pruebas de Integración con Ava, Supertest y Sinon

Asegurando nuestra API REST con JWT

47

Definición de JWT

48

Asegurando nuestra API con express-jwt

49

Modificando las pruebas de integracion

50

Implementando permisos con express-jwt-permissions

Creando un Dashboard Web en tiempo real con WebSockets (platziverse-web)

51

Implementación de un servidor web estático con express

52

Integrando socket.io con express

53

Integrando agente de monitoreo con socket.io

54

Implementación de rutas proxy con la API

55

Presentación de nuestro cliente frontend en Vue.js

56

Integración del cliente frontend con API (Metric)

57

Integración del cliente frontend con socket.io (Metric)

58

Integración del cliente frontend con API (Agent)

59

Integración del cliente frontend con socket.io (Agent)

Creando un Dashboard para la terminal en tiempo real con Blessed (platziverse-cl)

60

Implementación de un CLI Básico con Node

61

Introducción a Blessed / Blessed Contrib

62

Implementación del layout básico con Blessed Contrib

63

Integración con el agente de monitoreo 1

64

Integración con el agente de monitoreo 2

65

Integración con el agente de monitoreo 3

Depurando Aplicaciones Node.js

66

Utilizando longjohn para mejores stacktraces

67

Depurando en Desarrollo con node --inspect

68

Depurando en Desarrollo con Visual Studio Code

Preparando nuestra aplicación para producción

69

Preparando Proyecto para Producción 1

70

Preparando Proyecto para Producción 2

71

Creación de scripts para despliegue con Ansible

72

Probando el database rol con Vagrant

73

Creando scripts del rol de platziverse db y mqtt (script de automatización .yml)

74

Terminando los scripts faltantes

75

Creación de servidores en DigitalOcean

Desplegando nuestra aplicación a producción

76

Ejecutando los Scripts de Despliegue

77

Utilizando Aplicación en Producción y cierre del curso

Bonus: Utilizando platziverse-agent en BeagleBone Black y Raspberry PI

78

Implementación platziverse-agent con Johnny-Five

No tienes acceso a esta clase

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

Reto: Cómo modificar el script de inicialización de la base de datos

26/78
Recursos

Nosotros creamos un script de la configuración de la base de datos. Este script lo vamos a querer ejecutar de forma automatizada. Más adelante cuando estemos haciendo deploy ese script no lo va a ejecutar un humano.

Reto #2:

Modificar el script de creación de base de datos para que evite el prompt de confirmación pasándole un flag --yes al script.

Aportes 16

Preguntas 0

Ordenar por:

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

Implemente la Libreria Yargs, para manejar los Parámetros

const argv = require('yargs').boolean('y').argv

Y cree una condición para ejecutar el Promt o no:

  const ops = argv.y
  if (!ops) {
    const answer = await prompt({
      type: 'confirm',
      name: 'setup',
      massage: 'This will destroy your DataBase, Are you Sure?'
    })
    if (!answer.setup || ops) {
      return console.log('Nothing happened :)')
    }
  }  

Lanzamos el comando setup:

npm run setup -- -y

Dejo mi solución 😃

Simplemente envolví el código relacionado al await prompt en un bloque if así:

if (!(process.argv.includes('-y') || process.argv.includes('--yes'))) {
    const userAnswer = await prompt([
      {
        type: 'confirm',
        name: 'proceed',
        message: 'This will destroy the database, Are you sure?',
      },
    ]);
    if (!userAnswer.proceed) {
      console.log(chalk.yellow('Setup aborted!'));
      process.exit(0);
    }
  }

Si la ejecución del script no recibe las flags -y o --y, hará la pregunta y esperará por una respuesta “humana”; de lo contrario, no hará la pregunta y correrá el script de setup.

Una versión con el módulo ‘command-line-args’.

'use strict'

const db = require('./')
const conf = require('../../conf/conf.json')
const chalk = require('chalk')
const debug = require('debug')('project:db:setup')
const inquirer = require('inquirer')
const cmdArgs = require('command-line-args')
const optionDefinitions = [
  { name: 'yes', alias: 'y', type: Boolean },
]
const parsedArgv = cmdArgs(optionDefinitions)

async function setup () {
	if ( ! parsedArgv.yes ) {
		const answer = await inquirer.prompt([
			{
				'type': 'confirm',
				'name': 'setup',
				'message': 'This will be destroy the actual database, are you sure?',
			},
		])

		if ( ! answer.setup ) {
			console.log('Nothing happened :)')
			process.exit(0)
		}
	}

	const db_conf = {
		setup: true,
		logging: debug
	}

	await db(db_conf)

	console.log(`DATABASE SETUP ${chalk.green('SUCCESSFUL!')}`)
	process.exit(0)
}

setup()```

Opté por algo bien sencillo

if (process.argv.indexOf('-y') == -1) {
    const answer = await prompt([
      {
        type: 'confirm',
        name: 'setup',
        message: 'This will destroy your database, are you sure?'
      }
    ])

    if (!answer.setup) {
      return console.log('Nothing happened! :)')
    }
  }
if(!process.argv.includes('--y')) {
    const answer = await prompt([
      {
        type: 'confirm',
        name: 'setup',
        message: 'This will destroy your database, are you sure?'
      }
    ])
    if (!answer.setup) {
      return console.log('Nothing happened :)')
    }
  } ```
const forceDestroy = process.argv.indexOf('--force') >= 0

  if( ! forceDestroy ) {
    const answer = await prompt([
      {
        type: 'confirm',
        name: 'setup',
        message: 'This will destroy your database, are you sure?'
      }
    ])

    if (!answer.setup) {
      return console.log('Nothing happened!!')
    }
  }

Reto resuelto:

const commander = require('commander')

commander.option('-y, --yes', 'Acept the question and continue')
commander.parse(process.argv)

const prompt = inquirer.createPromptModule()

async function setup () {
  if (!commander.yes) {

    const answere = await prompt([
      {
        type: 'confirm',
        name: 'setup',
        message: 'This will destroy your database, are you sure?'
      }
    ])
  
    if (!answere.setup) {
      return console.log('Nothing happened!')
    }
  }
...
}

Reto resuelto. simple pero poderoso

'use strict'

const debug = require('debug')('platziverse:db:setup')
const inquirer = require('inquirer')
const chalk = require('chalk')
const db = require('./')

const prompt = inquirer.createPromptModule()

const args = process.argv.slice();
async function setup () {
  if(!args.includes( '-y') && !args.includes( '--yes' )){
    const answer = await prompt([
      {
        type: 'confirm',
        name: 'setup',
        message: 'This will destroy your database? are you sure?'
      }
    ])
    if (!answer.setup) {
      return console.log('Nothing happened :)')
    }
  }

  const config = {
    database: process.env.DB_NAME || 'platziverse',
    username: process.env.DB_USER || 'platzi',
    password: process.env.DB_PASS || 'platzi',
    host: process.env.DB_HOST || 'localhost',
    dialect: 'postgres',
    logging: (s) => debug(s),
    setup: true
  }

  await db(config).catch(handleFatalError)

  console.log('Success!')
  process.exit(0)
}

function handleFatalError (err) {
  console.error(`${chalk.red('[FATAL ERROR!!]')} ${err.message}`)
  console.error(err.stack)
  process.exit(1)
}

setup()

😎

Solución utilizando process.argv

'use strict'

const debug = require('debug')('platziverse:db:setup')
const inquirer = require('inquirer')
const chalk = require('chalk')
const db = require('./')

const prompt = inquirer.createPromptModule()

async function setup () {

  const arg = process.argv.slice(2)

  if (arg[0] === '--yes') {
    console.log('Yes from args - Continuing')
  } else {
    const answer = await prompt([
      {
        type: 'confirm',
        name: 'setup',
        message: 'This will destroy db, are you sure?'
      }
    ])

    if (!answer.setup) {
      return console.log('Nothing happened :)')
    }
  }

  const config = {
    database: process.env.DB_NAME || 'platziverse',
    username: process.env.DB_USER || 'platzi',
    password: process.env.DB_PASS || 'platzi',
    host: process.env.DB_HOST || 'localhost',
    dialect: 'postgres',
    setup: true,
    logging: s => debug(s)
  }

  await db(config).catch(handleFatalError)

  console.log('Success!')
  process.exit(0)
}

function handleFatalError (err) {
  console.error(err.message)
  console.error(err.stack)
  process.exit(1)
}

setup()

Reto superado, usando yargs

'use strict'
const debug = require('debug')('platziverse:db:setup')
const inquirer = require('inquirer')
const chalk = require('chalk')

const db = require('./')

const argv = require ('yargs')
  .boolean(['y','yes'])
  .argv

// console.dir([ argv.y, argv.yes ]);
// console.dir(argv._);

// hacer preguntas
const prompt = inquirer.createPromptModule()
async function setup () {
  let answer;

  if ( argv.y || argv.yes ) {
    answer = {
      setup: true
    } 
  } else {
    // Preguntar por consola
    answer = await prompt([
      {
        type: 'confirm',
        name: 'setup',
        message: 'This will destroy your databaase, are you sure?'
      }
    ])
  }
  
  if (!answer.setup) {
    return console.log('Nothing happend :)')
  }

  const config = {
    database: process.env.DB_NAME || 'platziverse',
    username: process.env.DB_USER || 'platzi',
    password: process.env.DB_PASS || 'platzi',
    host: process.env.DB_HOST || 'localhost',
    dialect: 'postgres',
    port: 5432,
    logging: log => debug(log),
    setup: true
  }

  await db(config).catch(handleFatalError)

  console.log('Success')
  process.exit(0)
}

function handleFatalError (err) {
  console.error(`${chalk.red('[fatal error]')} ${err.message}`)
  console.error(err.stack)
  process.exit(1)
}

setup()

Resuelto, algo sencillo sin otras dependencias

function getCommandFlags() {
  return process.argv.filter(val => val.startsWith('--') || val.startsWith('-'))
}

function validateAutomatedFlag() {
  return getCommandFlags().filter(val => val === '-y' || val === '--yes').length > 0
}

async function requestUserConfirmation() {
  return (await prompt([
    {
      type: 'confirm',
      name: 'setup',
      message: 'This will destroy your database, are you sure?'
    }
  ])).setup
}

async function setup() {

  if (!validateAutomatedFlag() && ! await requestUserConfirmation()) {
    return console.log('Nothing happened :)')
  }
...

}

Dentro de nuestra función setup añadir:

const [flagYes] = process.argv.slice(2) || null;
  const yesFlagExecute = (flagYes === '--yes' || flagYes === '-y');
  if (!yesFlagExecute) {
    const answer = await prompt([
      {
        type: 'confirm',
        name: 'setup',
        message: 'This will distroy your databse, are you sure?',
      },
    ]);

    if (!answer.setup) {
      return debug(chalk.greenBright('Your db is safe :) '));
    }
  }

Mi solución…

if (!process.argv.includes('--yes') && !process.argv.includes('-y')) {
    const answer = await prompt([
      {
        type: 'confirm',
        name: 'setup',
        message: 'This will destroy your database, are you sure?',
      },
    ]);

    if (!answer.setup) {
      return console.log('Nothing happended!')
    }
  }
const argv = require('yargs').option(
  'force', {
    alias: 'f',
    type: 'boolean',
    default: false,
    description: 'Not question!  destroy database',
    demandOption: false
  }).argv
async function setup () {
if (!argv.force) {
    const answer = await prompt([
      {
        type: 'confirm',
        name: 'setup',
        message: 'This will destroy your database, are you sure?'
      }
    ])

    if (!answer.setup) {
      return console.log('Nothing happened :)')
    }
  }