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

if (process.argv.pop() !== '--y') {
    const answer = await prompt([
      {
        type: 'confirm',
        name: 'setup',
        message: 'This will destroy your database, are you sure?'
      }
    ])
    if (!answer.setup) {
      return console.log(`${chalk.blue('Nothing happend :)')}`)
    }
  }```

Process Argv en NodeJS:
Guarda un Array con todos los parametros enviados al momento de ejecutar el script.js con NodeJS.

1. process.argv Imprime un arreglo.
2. process.argv[x] Imprime el valor de una posición del Array.

En el caso del fragmento del código número uno; con el método forEach se procede a recorrer el objeto de tipo Array e imprimer el respectivo valor de cada indice.

En el caso del fragmento del código número dos simplemente se determina si al ejecutar el script se pasó el parámetro --yes: Validando el valor de cada indice.

// Fragmento del código número uno:
process.argv.forEach((parametro, index) => {
  console.log(`[${index}] ${parametro}`)

  // Fragmento del código número dos:
  if (process.argv[index] == '--yes') {
    console.log(`El parámetro "${parametro}" se encontró en el indice [${index}]`)
  }
})

Teniendo en cuenta esto, aquí les dejo código de mi reto cumplido:

// Automatización del Script de creación de la Database
  let flag = false

  process.argv.forEach(e => {
    if (e === '--yes') {
      flag = true
    }
  })

  if (flag === false) {
    // Pregunta en la consola
    const answer = await prompt([
      {
        type: 'confirm',
        name: 'setup',
        message: 'This will destroy your database, are you sure?'
      }
    ])

    // Si la respuesta es falsa (es negativa), no pasa nada
    // Si la respuesta es verdadera (es positia), re-crea la DB
    if (!answer.setup) {
      return console.log('Nothing happended :)')
    }
  }

Muchas gracias por leer, espero que este aporte les ayude a entender este reto, de todas maneras aquí puedes leer más sobre este tema.

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! :)')
    }
  }

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

Buenas, dejo como resolví el reto:

async function setup() {
  const byPass = process.argv.indexOf('yes') !== -1
  
  if (!byPass) {
    const prompt = inquirer.createPromptModule()
    const answer = await prompt([
      {
        type: 'confirm',
        name: 'setup',
        message: 'Are you sure to destroy the database?'
      }
    ])
  
    if (!answer.setup) {
      return console.log('Nothing happend.')
    }
  }
  // ...
}

Se corre de la siguiente forma npm run setup -- yes.
Saludos!

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()

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.

😎

Que tal todos, les dejo mi implementación utilizando minimist:

Repositorio

Con filter

const yesFlag = process.argv.filter(flag => {
  return (flag.toLowerCase()) === '--y' || (flag.toLowerCase() === '--yes')
})[0]

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

// rest of setup.js code

}

LISTO:

async function setup () {
  const flags = process.argv[2]

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

    if (!awnser.setup) {
      return console.log('Nothing Happend!')
    }
  }

Al final he implementado la solución utilizando el paquete args-parser:

const args = require("args-parser")(process.argv)

async function setup () {

  if( !args.y && !args.yes) {
    const answer = await prompt([{
      type: 'confirm',
      name: 'setup',
      message: 'Esto destruirá la base de datos, seguro?'
    }])
  
    if (!answer.setup) {
      return console.log('Nothing happened :)')
    }
  }

  const config = {

Esta es mi solución!!

'use strict'

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

async function setup () {
  const value = process.argv.filter(arg => arg === '-y' || arg === '--yes')[0]

  if (value === '-y' || value === '--yes') {
    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: process.env.DB_USAGE || 'postgres',
      setup: true,
      logging: m => debug(m)
    }

    await db(config).catch(handleFatalError)

    console.log('Success!')
    process.exit(0)
  } else {
    console.log(chalk.green(`La base de datos esta a salvo`))
  }
}

setup()

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

Mi solución del reto:

async function setup() {

  switch (process.argv[2]) {
    case 'yes':
      {
        configDatabase();
        break;
      }
    default:
      {
        const answer = await prompt([{
          type: 'confirm',
          name: 'setup',
          message: 'This will destroy your database, are you sure?'
        }]);

        if (!answer.setup) {
          return console.log('Nothing happend :)');
        }
        configDatabase();
      }
  }

  async function configDatabase() {
    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);
  }
}

Por lo que veo todos hicieron un script si no pones el flag no haga nada pero si lo pones ya te pregunta, lo que Julian Duque dijo era que fuera opcional.

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

async function setup () {
  const flags = process.argv.indexOf('yes') === -1 && process.argv.indexOf('simon') === -1

  if (!flags) {
    createDB(config)
  } else {
    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 :) ')
    }
    createDB(config)
  }

}

async function createDB (config) {
  await db(config).catch(handleFatalError)
  console.log('Success!')
  process.exit(0)
}

Mi solución:

async function setup () {
  const fileIndex = process.argv.indexOf(__filename)
  let flag = true
  if (process.argv[fileIndex+1] == '--yes' || process.argv[fileIndex+1] == '-y' ){
    flag = false
  }
  if (flag){
    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 :)')
    }
  }
  //...
}

    let arg = false;
    process.argv.forEach((args) => {
        if(args == '--y')
         arg = true;
    })

    if(!arg)
       return

'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() {
  console.log(`${chalk.blue(process.argv.indexOf('-y') !== -1)} `);
  if (process.argv.indexOf('-y') !== -1) {
    /*const answer = await prompt([
      {
        type: 'confirm',
        name: 'setup',
        message: 'This will destroy your database, are you sure?'
      }
    ])*/
    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)
  } else {
    return console.log('Nothing happened :)')
  }
}

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!')
    }
  }

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 :)')
    }
  } ```

Tengo dificultades con este reto, una pregunta a priori muy simple este codigo suplante el anterior codigo en el archivo setup.js ??? o debemos crearlo aparte (imagino que si que lo suplanta pero no lo se )

if (process.argv.indexOf('-y') === -1){ }

let args = process.argv.filter(a => a.indexOf('--') != -1 || a.indexOf('-') )

  if (args.findIndex('--yes') == -1 || args.findIndex('-y') == -1) {
 .....
}

No entiendo por que voy a querer ejecutar el script de manera automatizada si el setup lo ejecutamos solo la primera vez

Soluciones sencilla:

async function setup () {
  const force = process.argv.slice(2).pop()
  if (force !== '-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 happpen :)')
    }
  } 
...

Otra opción es usar https://www.npmjs.com/package/nodejs-argv

let autoConfig=false;
if(process.argv[2]){
  if(process.argv[2].slice(2)=='auto'){
    autoConfig = true
  }
}

async function setup () {

  if(!autoConfig){
    const answer = await prompt([
      {
        type: 'confirm',
        name: 'setup',
        message: 'Este comando destruirá completamente su base de datos, \n \n ¿Esta usted seguro?'
      }
    ])
    if (!answer.setup) {
      return console.log('\n No se realizaron cambios en su base de datos!')
    }    
    await db(config).catch(handleFatalError)
    console.log('\n \n \n Proceso Completado Correctamente')
    process.exit(0)
  }
  else{
    await db(config).catch(handleFatalError)
    console.log('\n \n \n Proceso Completado Correctamente')
    process.exit(0)
  }
}

if(process.argv.pop() !== '-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 :)')
    }
   }

if(process.argv[2] != '--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 happend :)')
    }
  }

Vi muchas soluciones interesantes, pero quiero aportar otra solucion con el paquete yargs
npm i yargs -D

...
const argv = require('yargs').argv
const prompt = inquirer.createPromptModule()


async function setup() {
  if (!argv.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 :)')
    }
  }
...

y en la terminal
npm run setup – --yes

// Funciona, que opinan? Como lo mejorarían? (Quizás cambiarían el IF, sorpréndanme, gracias.

if(process.argv[2] != '--yes'){
   const anwser = await prompt([{
     type: 'confirm',
     name: 'setup',
     message: 'This will destroy your DB, are you sure?'
   }])
   if (!anwser.setup) return console.log('Nothing happened!')
 }

const recreate = process.argv.find(e => e.toLowerCase() == '--yes' || e.toLocaleLowerCase() == 'y')

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

Hay un paquete que nos ayuda a abstraer mas esa lógica, exactamente es este

en cuanto termine de implementarlo les paso el codigo