One place for hosting & domains

      módulos

      Cómo usar módulos Node.js con npm y package.json


      El autor seleccionó a Open Internet/Free Speech Fund para recibir una donación como parte del programa Write for DOnations.

      Introducción

      Debido a características como su rápido rendimiento de entrada y salida (E/S) y su sintaxis de JavaScript conocida, Node.js se convirtió velozmente en un entorno en tiempo de ejecución popular para desarrollo web de backend. Sin ambargo, a medida que crece el interés, se crean aplicaciones más grandes y se hace más difícil gestionar la complejidad de la base de código y sus dependencias. Node.js organiza esta complejidad usando módulos, que son archivos de JavaScript cualesquiera que contengan funciones u objetos que otros programas o módulos puedan usar. Las colecciones de uno o más módulos suelen citarse como paquetes y los administradores de paquetes los organizan.

      El administrador de paquetes de Node.js (npm) es el administrador de paquetes predeterminado y más popular del ecosistema de Node.js, y se utiliza principalmente para instalar y administrar módulos externos de proyectos de Node.js. También se suele utilizar para instalar una amplia variedad de herramientas de CLI y ejecutar secuencias de comandos de proyectos. npm realiza un seguimiento de los módulos instalados en un proyecto con el archivo package.json, que reside en el directorio de un proyecto y contiene lo siguiente:

      • Todos los módulos necesarios para un proyecto y sus versiones instaladas
      • Todos los metadatos de un proyecto, como el autor y la licencia, entre otros
      • Secuencias de comandos que se pueden ejecutar para automatizar tareas del proyecto

      Al crear proyectos más complejos de Node.js, administrar sus metadatos y dependencias con el archivo package.json, proporcionará compilaciones más previsibles, ya que todas las dependencias externas se mantienen iguales. El archivo hará un seguimiento de esta información de forma automática; si bien puede cambiar el archivo directamente para actualizar los metadatos de su proyecto, rara vez deberá interactuar con él directamente para administrar módulos.

      A través de este tutorial, gestionará paquetes con npm. El primer paso será crear y comprender el archivo package.json. Luego, lo usará para realizar un seguimiento de todos los módulos que instale en su proyecto. Por último, enumerará las dependencias de sus paquetes, los actualizará, los desinstalará y realizará una auditoría para detectar errores de seguridad en ellos.

      Requisitos previos

      Para completar este tutorial, necesitará lo siguiente:

      Paso 1: Crear un archivo package.json

      El primer paso de este tutorial es establecer el proyecto de ejemplo: un módulo locator ficticio de Node.js que obtiene la dirección IP del usuario y muestra el país de origen. En este tutorial, no codificará el módulo. Sin embargo, los paquetes que administre serían pertinentes si lo desarrollara.

      Primero, creará un archivo package.json para almacenar los metadatos útiles sobre el proyecto y como ayuda para administrar los módulos de Node.js dependientes del proyecto. Como sugiere el sufijo, este es un archivo JSON (notación de objetos JavaScript). JSON es un formato estándar que se utiliza para compartir, basado en objetos de JavaScript, y consta de datos almacenados como pares clave-valor. Si desea obtener más información sobre JSON, consulte nuestro artículo Introducción a JSON.

      Debido a que un archivo package.json contiene numerosas propiedades, puede ser engorroso crearlo manualmente, sin copiar ni pegar una plantilla desde otro sitio. Para facilitar las cosas, npm proporciona el comando init. Se trata de un comando interactivo que le formula una serie de preguntas y crea un archivo package.json basado en sus respuestas.

      Usar el comando init

      Primero, configure un proyecto para poder poner en práctica la administración de módulos. En su shell, cree una nueva carpeta llamada locator:

      Luego, posiciónese en la nueva carpeta:

      Ahora, inicie el comando interactivo ingresando lo siguiente:

      Nota: Si en su código se usará Git para el control de versiones, cree el repositorio de Git primero y luego ejecute npm init. El comando entiende de forma automática que se encuentra en una carpeta habilitada para Git. Si se configura un Git remoto, completa de forma automática el repositorio, los errores y los campos de la página de inicio de su archivo package.json. Si inicializó el repositorio después de crear el archivo package.json, deberá añadir esta información de forma manual. Para obtener más información sobre el control de versiones de Git, consulte nuestra serie Git: Instalación, uso y ramificaciones.

      Recibirá el siguiente resultado:

      Output

      This utility will walk you through creating a package.json file. It only covers the most common items, and tries to guess sensible defaults. See `npm help json` for definitive documentation on these fields and exactly what they do. Use `npm install <pkg>` afterwards to install a package and save it as a dependency in the package.json file. Press ^C at any time to quit. package name: (locator)

      Primero, se le solicitará el valor de name de su nuevo proyecto. Por defecto, el comando prevé que es el nombre de la carpeta en la que usted se encuentra. Los valores predeterminados de cada propiedad se muestran entre paréntesis (). Debido a que el valor predeterminado de name funciona para este tutorial, presione ENTER para aceptarlo.

      El siguiente valor que se debe introducir es version. Junto con name, este campo se requiere si su proyecto se compartirá con otros en el repositorio de paquetes npm.

      Nota: Se espera que los paquetes de Node.js sigan la guía de Versionamiento semántico (semver). Por lo tanto, el primer número será el de versión MAJOR, que solo cambia cuando se modifica la API. El segundo número será el de versión MINOR, que cambia cuando se añaden funciones. El último número será el de versión de PATCH, que cambia cuando se solucionan errores.

      Pulse INTRO para aceptar la versión predeterminada.

      El siguiente campo es description: una cadena útil para explicar lo que hace su módulo de Node.js. Nuestro proyecto ficticio locator obtendría la dirección IP del usuario y mostraría el país de origen. Un campo description adecuado sería Finds the country of origin of the incoming request​​​; por lo tanto, ingrese algo similar y presione INTRO. El campo description es muy útil cuando las personas buscan su módulo.

      En la siguiente solicitud se pedirá el entry point. Si alguien instala y usa requires para su módulo, lo que configure en entry point será lo primero que se cargará de su programa. El valor debe ser la ubicación relativa de un archivo de JavaScript, y se añadirá a la propiedad main de package.json. Pulse INTRO para conservar el valor predeterminado.

      Nota: La mayoría de los módulos tienen un archivo index.js como punto de entrada principal. Este es el valor predeterminado de la propiedad main de un package.json, que es el punto de entrada para los módulos npm. Si no encuentra package.json, Node.js intentará cargar index.js por defecto.

      A continuación, se le solicitará un test command, una secuencia de comandos ejecutable o un comando para ejecutar las pruebas de su proyecto. En muchos módulos populares de Node.js, las pruebas se escriben y ejecutan con Mocha, Jest, Jasmine u otros marcos de pruebas. Dado que las pruebas se encuentran fuera del alcance de este artículo, por ahora deje esta opción vacía y presione INTRO para continuar.

      Luego, el comando init solicitará el repositorio GitHub del proyecto. En este ejemplo, no lo usará. Por lo tanto, déjelo vacío también.

      Después del repositorio, el comando solicita keywords. Esta propiedad es una serie de cadenas con términos útiles que las personas pueden usar para encontrar su repositorio. Se recomienda tener un pequeño conjunto de palabras claves realmente relevantes para su proyecto, a fin de direccionar más la búsqueda. Enumere estas palabras claves como cadena, separando cada valor con una coma. Para este proyecto de ejemplo, ingrese ip,geo,country cuando se le solicite. El package.json terminado tendrá tres elementos en la matriz de keywords.

      El siguiente campo de la solicitud es author. Es útil para los usuarios de su módulo que quieran ponerse en contacto con usted. Por ejemplo, si alguien descubre una vulnerabilidad de seguridad en su módulo, puede usarlo para indicarle el problema, a fin de que pueda solucionarlo. El campo author es una cadena que tiene el siguiente formato:  "Name <Email> (Website)".  Por ejemplo, “Sammy <sammy@your_domain> (https://your_domain)" es un autor válido. Los datos de correo electrónico y sitio web son optativos: un autor válido puede ser, simplemente, un nombre. Añada sus datos de contacto como autor y confírmelos con INTRO.

      Por último, se le solicitará indicar la license. Con esto, se determinan los permisos legales y las limitaciones que los usuarios tendrán al usar su módulo. Muchos módulos de Node.js son de código abierto. Por lo tanto, npm establece ISC como valor predeterminado.

      En este punto, revisaría sus opciones de concesión de licencias y decidirá lo mejor para su proyecto. Para obtener más información sobre los diferentes tipos de licencias de código abierto, consulte esta lista de licencias de la Open Source Initiative. Si no desea proporcionar una licencia para un repositorio privado, puede escribir UNLICENSED en la solicitud. Para este ejemplo, utilice la licencia ISC predeterminada y presione INTRO para terminar este proceso.

      El comando init ahora mostrará el archivo package.json que creará. Tendrá un aspecto similar a este:

      Output

      About to write to /home/sammy/locator/package.json: { "name": "locator", "version": "1.0.0", "description": "Finds the country of origin of the incoming request", "main": "index.js", "scripts": { "test": "echo "Error: no test specified" && exit 1" }, "keywords": [ "ip", "geo", "country" ], "author": "Sammy <sammy@your_domain> (https://your_domain)", "license": "ISC" } Is this OK? (yes)

      Una vez que la información coincida con lo que ve aquí, presione INTRO para completar el proceso y crear el archivo package.json. Con este archivo, puede llevar un registro de los módulos que instale para su proyecto.

      Ahora que tiene su archivo package.json, puede probar la instalación de módulos en el siguiente paso.

      Paso 2: Instalar módulos

      En el desarrollo de software, es habitual usar bibliotecas externas para realizar tareas auxiliares en los proyectos. Esto permite que el desarrollador se centre en la lógica empresarial y cree la aplicación de forma más rápida y eficiente.

      Por ejemplo, si el módulo locator de nuestro ejemplo tuviera que hacer una solicitud de API externa para obtener datos geográficos, podríamos usar una biblioteca HTTP para facilitar esa tarea. Debido a que nuestro objetivo principal es devolver al usuario datos geográficos pertinentes, podríamos instalar un paquete que nos facilite las solicitudes HTTP en lugar de tener que volver a escribir este código nosotros mismos, una tarea que va más allá del alcance de nuestro proyecto.

      Veamos este ejemplo. En su aplicación locator, usará la biblioteca axios, que lo ayudará a realizar solicitudes HTTP. Instálela ingresando lo siguiente en su shell:

      Este comando se inicia con npm install, que instalará el paquete (para abreviar, puede usar npm i). Luego, enumere los paquetes que desea instalar, separados por un espacio. En este caso, es axios. Por último, finalice el comando con el parámetro opcional --save, que especifica que axios se guardará como dependencia del proyecto.

      Cuando se instale la biblioteca, verá un resultado similar al siguiente:

      Output

      ... + axios@0.19.0 added 5 packages from 8 contributors and audited 5 packages in 0.764s found 0 vulnerabilities

      Ahora, abra el archivo package.json con el editor de texto que prefiera. En este tutorial, se usará nano:

      Verá una nueva propiedad, resaltada en lo siguiente:

      locator/package.json

      {
        "name": "locator",
        "version": "1.0.0",
        "description": "Finds the country of origin of the incoming request",
        "main": "index.js",
        "scripts": {
          "test": "echo "Error: no test specified" && exit 1"
        },
        "keywords": [
          "ip",
          "geo",
          "country"
        ],
        "author": "Sammy sammy@your_domain (https://your_domain)",
        "license": "ISC",
        "dependencies": {
          "axios": "^0.19.0"
        }
      }
      

      La opción --save indicó a npm que actualizara package.json con el módulo y la versión que se acaba de instalar. Esto es muy positivo, ya que otros desarrolladores que trabajen en sus proyectos podrán ver fácilmente las dependencias externas necesarias.

      Nota: Seguramente haya observado el ^ antes del número de versión de la dependencia axios. Recuerde que el control de versiones semántico consta de tres dígitos: MAJOR, MINOR y PATCH. El símbolo ^ indica que cualquier versión MINOR o PATCH superior cumpliría con esta restricción de versión. Si ve ~ al comienzo de un número de versión, solo las versiones PATCH superiores satisfacen la restricción.

      Cuando termine de revisar package.json, cierre el archivo.

      Dependencias de desarrollo

      Los paquetes que se utilizan para desarrollar proyectos, pero no para crearlos o ejecutarlos en producción, se conocen como dependencias de desarrollo. No son necesarios para que su módulo o aplicación funcionen en producción, pero pueden ser útiles al escribir el código.

      Por ejemplo, es común que los desarrolladores utilicen linters de código para asegurarse de que su código siga las prácticas recomendadas y mantener un estilo uniforme. Si bien esto es útil para el desarrollo, solo aumenta el tamaño del código que puede distribuirse y no proporciona un beneficio tangible cuando se implementa en producción.

      Instale un linter como dependencia de desarrollo para su proyecto. Pruebe esto en su shell:

      • npm i eslint@6.0.0 --save-dev

      En este comando, utilizó el indicador --save-dev. Este indicador guardará eslint como una dependencia que solo se requiere para el desarrollo. Tenga en cuenta, también, que añadió @6.0.0 al nombre de su dependencia. Cuando los módulos se actualizan, se etiquetan con una versión. La @ indica a npm que busque una etiqueta específica del módulo que está instalando. Si no se especifica una etiqueta, npm instala la última versión etiquetada. Vuelva a abrir package.json:

      Con esto, se mostrará lo siguiente:

      locator/package.json

      {
        "name": "locator",
        "version": "1.0.0",
        "description": "Finds the country of origin of the incoming request",
        "main": "index.js",
        "scripts": {
          "test": "echo "Error: no test specified" && exit 1"
        },
        "keywords": [
          "ip",
          "geo",
          "country"
        ],
        "author": "Sammy sammy@your_domain (https://your_domain)",
        "license": "ISC",
        "dependencies": {
          "axios": "^0.19.0"
        },
        "devDependencies": {
          "eslint": "^6.0.0"
        }
      }
      

      eslint se guardó como devDependencies, junto con el número de versión que especificó anteriormente. Cierre package.json.

      Archivos generados de forma automática: node_modules y package-lock.json

      La primera vez que se instala un paquete en un proyecto de Node.js, npm crea la carpeta node_modules para almacenar los módulos necesarios para su proyecto y el archivo package-lock.json que examinó antes.

      Confirme que estén presentes en su directorio de trabajo. En su shell, escriba ls y presione INTRO. Verá el siguiente resultado:

      Output

      node_modules package.json package-lock.json

      La carpeta node_modules contiene todas las dependencias instaladas de su proyecto. En la mayoría de los casos, no debe confirmar esta carpeta en su repositorio de versiones controladas. A medida que instale más dependencias, el tamaño de esta carpeta aumentará rápidamente. Además, el archivo package-lock.json lleva un registro de las versiones exactas instaladas de forma más concisa. Por lo tanto, no es necesario incluir node_modules.

      Si bien el archivo package.json enumera dependencias que indican las versiones adecuadas que se deben instalar en el proyecto, el archivo package-lock.json hace un seguimiento de todos los cambios que se realizan en package.json o node_modules y nos indica la versión exacta del paquete instalado. En general, confirma esto en su repositorio de versiones controladas, en lugar de node_modules, dado que es una representación más clara de todas sus dependencias.

      Realizar la instalación desde package.json

      Con sus archivos package.json y package-lock.json, puede configurar rápidamente las mismas dependencias del proyecto antes de comenzar a desarrollar uno nuevo. Para demostrarlo, suba un nivel en su árbol de directorios y cree una nueva carpeta denominada cloned_locator en el mismo nivel de directorio de locator:

      • cd ..
      • mkdir cloned_locator

      Posiciónese en su nuevo directorio:

      Ahora, copie los archivos package.json y package-lock.json de locator a cloned_locator:

      • cp ../locator/package.json ../locator/package-lock.json .

      Para instalar los módulos requeridos para este proyecto, escriba lo siguiente:

      npm buscará un archivo package-lock.json para instalar los módulos. Si no hubiera ningún archivo de bloqueo disponible, leería el archivo package.json para determinar las instalaciones. En general, la instalación se puede realizar de manera más rápida desde package-lock.json, ya que el archivo de bloqueo contiene la versión exacta de los módulos y sus dependencias, lo cual significa que npm no tiene que invertir tiempo en determinar una versión adecuada para la instalación.

      Al momento de la implementación en producción, tal vez prefiera omitir las dependencias de desarrollo. Recuerde que las dependencias de desarrollo se almacenan en la sección devDependencies de package.json y que no afectan el funcionamiento de su aplicación. Al instalar módulos como parte del proceso de CI y CD para implementar su aplicación, omita las dependencias de desarrollo ejecutando lo siguiente:

      El indicador --production ignora la sección devDependencies durante la instalación. Por ahora, siga adelante con su compilación de desarrollo.

      Antes de pasar a la siguiente sección, regrese a la carpeta locator:

      Instalaciones globales

      Hasta ahora, instaló módulos npm para el proyecto locator. npm también le permite instalar paquetes de forma global. Esto significa que el paquete está disponible para su usuario en el sistema más amplio, como cualquier otro comando shell. Esta capacidad es útil para muchos módulos de Node.js que son herramientas de CLI.

      Por ejemplo, tal vez desee hacer un blog sobre el proyecto locator en el que trabaja actualmente.  Para hacerlo, puede usar una biblioteca como Hexo para crear y administrar su blog de sitio web estático. Instale la CLI de Hexo de forma global, como se indica a continuación:

      Para instalar un paquete de forma global, anexe el indicador -g al comando.

      Nota: Si observa un error de permiso al intentar instalar este paquete de forma global, es posible que su sistema requiera privilegios de superusuario para ejecutar el comando. Vuelva a probar con sudo npm i hexo-cli -g.

      Pruebe que el paquete se haya instalado de forma correcta escribiendo lo siguiente:

      Verá un resultado similar a este:

      Output

      hexo-cli: 2.0.0 os: Linux 4.15.0-64-generic linux x64 http_parser: 2.7.1 node: 10.14.0 v8: 7.6.303.29-node.16 uv: 1.31.0 zlib: 1.2.11 ares: 1.15.0 modules: 72 nghttp2: 1.39.2 openssl: 1.1.1c brotli: 1.0.7 napi: 4 llhttp: 1.1.4 icu: 64.2 unicode: 12.1 cldr: 35.1 tz: 2019a

      Hasta ahora, aprendió a instalar módulos con npm. Puede instalar paquetes en un proyecto de forma local, ya sea como dependencia de producción o de desarrollo. También puede instalar paquetes basados en archivos package.json o package-lock.json preexistentes, lo que le permite realizar desarrollos con las mismas dependencias que sus pares. Por último, puede usar el indicador -g para instalar paquetes de forma global, a fin de poder acceder a ellos independientemente de que se encuentre en un proyecto de Node.js o no.

      Ahora que puede instalar módulos, en la siguiente sección, practicará técnicas para administrar sus dependencias.

      Paso 3: Administrar módulos

      Un administrador de paquetes completo puede hacer mucho más que instalar módulos. npm tiene más de 20 comandos disponibles relacionados con la administración de dependencias. En este paso, hará lo siguiente:

      • Enumerará módulos que instaló.
      • Actualizará módulos a una versión más reciente.
      • Desinstalará los módulos que ya no necesite.
      • Ejecutará una auditoría de seguridad en sus módulos para encontrar y solucionar errores de seguridad.

      Si bien estos ejemplos se ejecutarán en su carpeta locator, todos estos comandos se pueden ejecutar de forma global añadiéndoles el indicador -g al final, exactamente lo mismo que hizo al realizar la instalación global.

      Enumerar módulos

      Si quisiera saber qué módulos se instalan en un proyecto, sería más fácil usar el comando list o ls en lugar de leer directamente package.json. Para hacerlo, ingrese lo siguiente:

      Verá un resultado similar a este:

      Output

      ├─┬ axios@0.19.0 │ ├─┬ follow-redirects@1.5.10 │ │ └─┬ debug@3.1.0 │ │ └── ms@2.0.0 │ └── is-buffer@2.0.3 └─┬ eslint@6.0.0 ├─┬ @babel/code-frame@7.5.5 │ └─┬ @babel/highlight@7.5.0 │ ├── chalk@2.4.2 deduped │ ├── esutils@2.0.3 deduped │ └── js-tokens@4.0.0 ├─┬ ajv@6.10.2 │ ├── fast-deep-equal@2.0.1 │ ├── fast-json-stable-stringify@2.0.0 │ ├── json-schema-traverse@0.4.1 │ └─┬ uri-js@4.2.2 ...

      Por defecto, Is muestra todo el árbol de dependencias: los módulos de los que depende su proyecto y los módulos de los que dependen sus dependencias. Puede ser algo engorroso si desea obtener una descripción general de alto nivel de lo que se instala.

      Para imprimir únicamente los módulos que instaló sin sus dependencias, ingrese lo siguiente en su shell:

      El resultado será el siguiente:

      Output

      ├── axios@0.19.0 └── eslint@6.0.0

      La opción --depth le permite especificar el nivel del árbol de dependencias que desea ver. Cuando es 0, solo se ven dependencias de nivel superior.

      Actualizar módulos

      Se le recomienda mantener sus módulos npm actualizados. Al hacerlo, tiene más posibilidades de acceder a las últimas correcciones de seguridad para ellos. Utilice el comando outdated para verificar si hay actualizaciones para alguno de sus módulos:

      Obtendrá un resultado similar al siguiente:

      Output

      Package Current Wanted Latest Location eslint 6.0.0 6.7.1 6.7.1 locator

      Con este comando, primero se enumeran el Package (paquete) que está instalado y la versión Current (actual). En la columna Wanted (deseado), se muestra la versión que cumple su requisito de versión en package.json. La columna Latest (última) muestra la versión más reciente del módulo que se publicó.

      La columna Location (ubicación) indica dónde se encuentra el paquete en el árbol de dependencias. El comando outdated tiene el indicador --depth como Is. Por defecto, la profundidad es 0.

      Parece que puede actualizar eslint a una versión más reciente. Utilice los comandos update o up como se indica a continuación:

      El resultado del comando contendrá la versión instalada:

      Output

      npm WARN locator@1.0.0 No repository field. + eslint@6.7.1 added 7 packages from 3 contributors, removed 5 packages, updated 19 packages, moved 1 package and audited 184 packages in 5.818s found 0 vulnerabilities

      Si quisiera actualizar todos los módulos a la vez, debería ingresar lo siguiente:

      Desinstalar módulos

      El comando uninstall de npm se utiliza para eliminar módulos de sus proyectos. Esto significa que el módulo ya no se instalará en la carpeta node_modules ni se verá en sus archivos package.json y package-lock.json.

      Eliminar dependencias de un proyecto es una actividad normal del ciclo de vida de desarrollo de software. Es posible que una dependencia no resuelva el problema tal como se anuncia o que no proporcione una experiencia de desarrollo satisfactoria.  En estos casos, es mejor que desinstale la dependencia y cree su propio módulo.

      Imagine que axios no proporciona la experiencia de desarrollo que hubiera deseado para realizar solicitudes HTTP. Desinstale axios con el comando uninstall o un ingresando lo siguiente:

      El resultado será similar a este:

      Output

      npm WARN locator@1.0.0 No repository field. removed 5 packages and audited 176 packages in 1.488s found 0 vulnerabilities

      No se indica de forma explícita que se eliminó axios. Para verificar que se haya desinstalado, vuelva a enumerar las dependencias una vez más:

      Ahora, se ve que solo eslint está instalado:

      Output

      └── eslint@6.7.1

      Esto indica que desinstaló el paquete axios de forma exitosa.

      Auditar módulos

      npm proporciona un comando audit para resaltar posibles riesgos de seguridad de sus dependencias. Para ver la auditoría en acción, instale una versión obsoleta del módulo request ejecutando lo siguiente:

      Cuando instale esta versión obsoleta de request, obtendrá un resultado similar al siguiente:

      Output

      + request@2.60.0 added 54 packages from 49 contributors and audited 243 packages in 7.26s found 6 moderate severity vulnerabilities run `npm audit fix` to fix them, or `npm audit` for details

      npm le indica que hay vulnerabilidades en sus dependencias. Para obtener más información, audite todo el proyecto con lo siguiente:

      Con el comando audit se muestran tablas de resultados en las que se resaltan errores de seguridad:

      Output

      === npm audit security report === # Run npm install request@2.88.0 to resolve 1 vulnerability ┌───────────────┬──────────────────────────────────────────────────────────────┐ │ Moderate │ Memory Exposure │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Package │ tunnel-agent │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Dependency of │ request │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Path │ request > tunnel-agent │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ More info │ https://npmjs.com/advisories/598 │ └───────────────┴──────────────────────────────────────────────────────────────┘ # Run npm update request --depth 1 to resolve 1 vulnerability ┌───────────────┬──────────────────────────────────────────────────────────────┐ │ Moderate │ Remote Memory Exposure │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Package │ request │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Dependency of │ request │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Path │ request │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ More info │ https://npmjs.com/advisories/309 │ └───────────────┴──────────────────────────────────────────────────────────────┘ ...

      Puede ver la ruta de la vulnerabilidad y, a veces, npm le ofrece formas de corregirla. Puede ejecutar el comando update, como se sugiere, o el subcomando fix de audit. En su shell, ingrese lo siguiente:

      Verá un resultado similar a este:

      Output

      + request@2.88.0 added 19 packages from 24 contributors, removed 32 packages and updated 12 packages in 6.223s fixed 2 of 6 vulnerabilities in 243 scanned packages 4 vulnerabilities required manual review and could not be updated

      npm pudo actualizar de forma segura dos de los paquetes, lo que redujo sus vulnerabilidades en la misma cantidad. Sin embargo, aún tiene cuatro vulnerabilidades en sus dependencias. El comando audit fix no siempre soluciona todos los problemas. Si bien la versión de un módulo puede tener una vulnerabilidad de seguridad, si lo actualiza a una versión con una API diferente podría desglosar el código en un nivel más alto del árbol de dependencias.

      Puede usar el parámetro --force para garantizar que se hayan eliminado las vulnerabilidades, como se indica a continuación:

      Como se mencionó anteriormente, esto no se recomienda a menos que esté seguro de que la funcionalidad no se verá afectada.

      Conclusión

      A lo largo de este tutorial, realizó varios ejercicios para demostrar cómo se organizan los módulos de Node.js en paquetes y la forma en que npm los gestiona. En un proyecto de Node.js, utilizó paquetes npm como dependencias creando y manteniendo un archivo package.json: un registro de los metadatos de su proyecto que incluye los módulos que instaló. También utilizó la herramienta CLI de npm para instalar, actualizar y eliminar módulos, así como para enumerar el árbol de dependencias de sus proyectos y verificar y actualizar los módulos obsoletos.

      En el futuro, aprovechar el código existente usando módulos acelerará el tiempo de desarrollo, dado que no es necesario que repita funcionalidades. También podrá crear sus propios módulos npm y estos, a su vez, serán gestionados por otros a través de comandos npm.  En cuanto a los siguientes pasos, experimente con lo que aprendió en este tutorial instalando y probando los diferentes paquetes disponibles. Vea lo que se ofrece en el ecosistema para facilitar la resolución de problemas. Por ejemplo, puede probar TypeScript, un supraconjunto de JavaScript, o convertir su sitio web en aplicaciones móviles con Cordova. Si desea obtener más información sobre Node.js, consulte nuestros otros tutoriales de Node.js.



      Source link

      Como usar os módulos do Node.js com o npm e o package.json


      O autor selecionou a Open Internet/Free Speech Fund para receber uma doação como parte do programa Write for DOnations.

      Introdução

      Devido a funcionalidades como sua performance rápida de Input/Output (I/O), bem como sua sintaxe bastante conhecida em JavaScript, o Node.js se tornou rapidamente um ambiente de execução popular para o desenvolvimento Web de back-end. No entanto, à medida que o interesse cresce, aplicativos maiores são construídos e a complexidade da base de código e suas dependências torna-se mais difícil. O Node.js organiza esta complexidade usando módulos, que são todos os arquivos únicos do JavaScript que contêm funções ou objetos que podem ser usados por outros programas ou módulos. Uma coleção de um ou mais módulos é geralmente conhecida como um pacote e esses pacotes são organizados por gerenciadores de pacotes.

      O Gerenciador de pacotes do Node.js (npm) é o gerenciador de pacotes padrão e o mais popular no ecossistema do Node.js, sendo usado principalmente para instalar e gerenciar módulos externos em um projeto do Node.js. Ele também é comumente usado para instalar uma ampla faixa de ferramentas CLI e executar scripts de projeto. O npm rastreia os módulos instalados em um projeto com o arquivo package.json, que reside em um diretório de projeto e contém:

      • Todos os módulos necessários para um projeto e suas versões instaladas
      • Todos os metadados para um projeto, como o autor, a licença, etc.
      • Scripts que podem ser executados para automatizar tarefas dentro do projeto

      Conforme cria projetos mais complexos do Node.js, gerenciar seus metadados e dependências com o arquivo package.json dará a você compilações mais previsíveis, uma vez que todas as dependências externas são mantidas as mesmas. O arquivo acompanhará essas informações automaticamente; embora possa alterar o arquivo diretamente para atualizar os metadados do seu projeto, você raramente precisará interagir com ele diretamente para gerenciar os módulos.

      Neste tutorial, você gerenciará pacotes com o npm. O primeiro passo será criar e entender o arquivo package.json. Então, você o utilizará para acompanhar todos os módulos que instalar em seu projeto. Por fim, listará as dependências do seu pacote, atualizará seus pacotes, desinstalará os pacotes e executará uma auditoria para encontrar falhas de segurança neles.

      Pré-requisitos

      Para completar este tutorial, você precisará de:

      Passo 1 — Criando um arquivo package.json

      Começamos este tutorial configurando o projeto exemplo — um módulo fictício locator do Node.js que recebe o endereço IP do usuário e retorna o país de origem. Você não vai codificar o módulo neste tutorial. No entanto, os pacotes que você gerencia seriam relevantes caso estivesse os desenvolvendo.

      Primeiro, será criado um arquivo package.json para armazenar metadados úteis sobre o projeto e ajudar você a gerenciar os módulos Node.js dependentes do projeto. Como o sufixo sugere, este é um arquivo JSON (Notação de objetos JavaScript). O JSON é um formato padrão usado para compartilhamento, com base nos objetos do JavaScript e constituído por dados armazenados como pares de chave-valor. Caso queira aprender mais sobre o JSON, leia nosso artigo Introdução ao JSON.

      Como um arquivo package.json contém várias propriedades, pode ser complicado criá-lo manualmente, sem copiar e colar um modelo de outro lugar. Para facilitar as coisas, o npm fornece o comando init. Este é um comando interativo que faz uma série de perguntas e cria um arquivo package.json com base em suas respostas.

      Como usar o comando init

      Primeiro, monte um projeto para que você possa praticar o gerenciamento de módulos. No seu shell, crie uma nova pasta chamada locator:

      Então, vá até o novo diretório:

      Agora, inicialize o prompt interativo digitando:

      Nota: se seu código for usar o Git para o controle de versão, crie o repositório Git primeiro para, em seguida, executar npm init. O comando compreende automaticamente que está em uma pasta habilitada para o Git. Caso um Git remoto esteja definido, ele preenche automaticamente os campos do repository, bugs e homepage para o seu arquivo package.json. Caso tenha inicializado o repositório após criar o arquivo package.json, será necessário adicionar essas informações você mesmo. Para obter mais informações sobre o controle de versão do Git, consulte nossa série Introdução ao Git: instalação, uso e ramificações.

      Você receberá o seguinte resultado:

      Output

      This utility will walk you through creating a package.json file. It only covers the most common items, and tries to guess sensible defaults. See `npm help json` for definitive documentation on these fields and exactly what they do. Use `npm install <pkg>` afterwards to install a package and save it as a dependency in the package.json file. Press ^C at any time to quit. package name: (locator)

      Primeiro, será solicitado o name (nome) do seu novo projeto. Por padrão, o comando supõe que este seja o nome da pasta em que você está. Os valores padrão para cada propriedade são mostrados entre parênteses (). Como o valor padrão para o name irá funcionar para este tutorial, pressione ENTER para aceitá-lo.

      O próximo valor a ser adicionado é version (versão). Junto com o name, este campo é necessário caso seu projeto seja compartilhado com outros no repositório de pacotes do npm.

      Nota: espera-se que os pacotes do Node.js sigam o guia Versionamento semântico (semver). Portanto, o primeiro número será o número de versão MAJOR, que muda somente quando a API muda. O segundo número será da versão do MINOR, que muda quando funcionalidades são adicionadas. O último número será da versão do PATCH, que muda quando bugs são consertados.

      Pressione ENTER para que a versão padrão seja aceita.

      O próximo campo é description (descrição) — uma string útil para explicar o que o seu módulo Node.js faz. Nosso projeto fictício locator recebe o endereço IP do usuário para retornar o país de origem. Uma description adequada seria Finds the country of origin of the incoming request (Encontra o país de origem da solicitação de entrada), então digite algo nesse sentido e pressione ENTER. A description é muito útil quando as pessoas estiverem à procura do seu módulo.

      O prompt a seguir irá solicitar o entry point (ponto de entrada). Caso alguém instale e exija seu módulo pelo comando requires, o que você definiu no entry point será a primeira parte do seu programa a ser carregada. O valor precisa ser o local relativo de um arquivo JavaScript e será adicionado à propriedade main do package.json. Pressione ENTER para manter o valor padrão.

      Nota: a maioria dos módulos tem um arquivo index.js como o ponto de entrada principal. Este é o valor padrão para a propriedade main do package.json, que é o ponto de entrada para os módulos do npm. Caso não haja um package.json, o Node.js tentará carregar o index.js por padrão.

      Em seguida, será solicitado a um test command (comando teste) a você, um script executável ou comando para executar seus testes de projeto. Em muitos módulos populares do Node.js, os testes são escritos e executados com o Mocha, Jest, Jasmine, ou outros frameworks de teste. Como os testes estão além do âmbito deste artigo, deixe esta opção vazia por enquanto e pressione ENTER para continuar.

      Então, o comando init irá pedir pelo repositório do GitHub do projeto. Você não usará isso neste exemplo, então deixe-o vazio também.

      Após o prompt do repositório, o comando solicita keywords (palavras-chave). Essa propriedade é uma matriz de strings com termos úteis que as pessoas podem usar para encontrar seu repositório. É melhor ter um pequeno conjunto de palavras que são realmente relevantes para o seu projeto, de forma que a busca seja mais direcionada. Liste essas palavras-chave como uma string com vírgulas separando cada valor. Para este projeto de amostra, digite ip,geo,country no prompt. O package.json finalizado terá três itens na matriz para keywords.

      O próximo campo no prompt é o author (autor). Ele é útil para os usuários do seu módulo que querem entrar em contato com você. Por exemplo, caso alguém descubra uma falha em seu módulo, essa pessoa pode usar isso para informar o problema, para que você possa corrigi-lo. O campo de author é uma string no seguinte formato: "Name <Email> (Website)" Por exemplo, "Sammy <sammy@your_domain> (https://your_domain)" é um autor válido. Os dados de e-mail e do site são opcionais — um autor válido poderia ser apenas um nome. Adicione seus detalhes de contato como autor e confirme com ENTER.

      Por fim, você será solicitado a colocar a license (licença). Isso determina as permissões e limitações legais que os usuários terão ao usar seu módulo. Muitos módulos do Node.js são de código aberto, então o npm define o padrão para ISC.

      Neste ponto, você deveria revisar suas opções de licenciamento e decidir o que é melhor para o seu projeto. Para obter mais informações sobre diferentes tipos de licenças de código aberto, consulte esta lista de licenças da Iniciativa Open Source. Caso não queira fornecer uma licença para um repositório privado, você pode digitar UNLICENSED no prompt. Para essa amostra, utilize a licença padrão ISC e pressione ENTER para finalizar esse processo.

      O comando init exibirá agora o arquivo package.json que ele criará. Ele ficará parecido com este:

      Output

      About to write to /home/sammy/locator/package.json: { "name": "locator", "version": "1.0.0", "description": "Finds the country of origin of the incoming request", "main": "index.js", "scripts": { "test": "echo "Error: no test specified" && exit 1" }, "keywords": [ "ip", "geo", "country" ], "author": "Sammy <sammy@your_domain> (https://your_domain)", "license": "ISC" } Is this OK? (yes)

      Assim que as informações forem correspondentes ao que vê aqui, pressione ENTER para completar este processo e criar o arquivo package.json. Com este arquivo, você pode manter um registro dos módulos que instala para o seu projeto.

      Agora que tem seu arquivo package.json, você pode testar a instalação de módulos no próximo passo.

      Passo 2 — Instalando módulos

      É comum no desenvolvimento de software utilizar bibliotecas externas para realizar tarefas auxiliares em projetos. Isso permite que o desenvolvedor se concentre na lógica de negócios e crie o aplicativo com maior rapidez e eficiência.

      Por exemplo, caso nosso módulo de amostra locator tenha que fazer uma solicitação de API externa para obter dados geográficos, poderíamos utilizar uma biblioteca HTTP para facilitar essa tarefa. Como nosso objetivo principal é retornar dados geográficos pertinentes para o usuário, poderíamos instalar um pacote que torna as solicitações HTTP mais fáceis para nós, ao invés de reescrever esse código por conta própria. O que seria uma tarefa que está além do âmbito do nosso projeto.

      Vamos testar este exemplo. No seu aplicativo locator, você utilizará a biblioteca axios, que ajudará você a fazer solicitações HTTP. Instale-a digitando o seguinte em seu shell:

      Você inicia este comando com o npm install, que instalará o pacote (para ser conciso, pode utilizar o npm i). Então, liste os pacotes que deseja que sejam instalados, separados por um espaço. Neste caso, trata-se do axios. Por fim, você termina o comando com o parâmetro opcional --save, que especifica que o axios será salvo como uma dependência do projeto.

      Quando a biblioteca for instalada, você verá um resultado similar ao seguinte:

      Output

      ... + axios@0.19.0 added 5 packages from 8 contributors and audited 5 packages in 0.764s found 0 vulnerabilities

      Agora, abra o arquivo package.json, usando um editor de texto de sua escolha. Este tutorial usará o nano.

      Você verá uma nova propriedade, assim como destacado a seguir:

      locator/package.json

      {
        "name": "locator",
        "version": "1.0.0",
        "description": "Finds the country of origin of the incoming request",
        "main": "index.js",
        "scripts": {
          "test": "echo "Error: no test specified" && exit 1"
        },
        "keywords": [
          "ip",
          "geo",
          "country"
        ],
        "author": "Sammy sammy@your_domain (https://your_domain)",
        "license": "ISC",
        "dependencies": {
          "axios": "^0.19.0"
        }
      }
      

      A opção --save disse ao npm para atualizar o package.json com o módulo e versão que acabou de ser instalada. Isso é ótimo, já que outros desenvolvedores trabalhando em seus projetos podem ver facilmente quais dependências externas são necessárias.

      Nota: você deve ter notado o ^ antes do número de versão para a dependência do axios. Lembre-se que o versionamento semântico consiste em três dígitos: MAJOR, MINOR e PATCH. O símbolo de ^ significa que qualquer versão superior do MINOR ou do PATCH atenderia a essa restrição de versão. Caso veja ~ no início de um número de versão, então apenas versões superiores do PATCH satisfazem a restrição.

      Quando terminar de revisar o package.json, saia do arquivo.

      Dependências de desenvolvimento

      Os pacotes que são usados para o desenvolvimento de um projeto, mas não para sua compilação ou execução na produção são chamados de dependências de desenvolvimento. Eles não são necessários para que seu módulo ou aplicativo funcione em produção, mas podem ser úteis ao escrever o código.

      Por exemplo, é comum que os desenvolvedores usem linters de código para garantir que seu código segue as melhores práticas e manter o estilo consistente. Embora seja útil para o desenvolvimento, isso apenas aumenta o tamanho do distribuível sem fornecer um benefício concreto quando implantado na produção.

      Instale um linter como uma dependência de desenvolvimento para seu projeto. Experimente isto em seu shell:

      • npm i eslint@6.0.0 --save-dev

      Neste comando, você usou o sinalizador --save-dev. Isso salvará o eslint como uma dependência que é necessária apenas para o desenvolvimento. Note também que você adicionou @6.0.0 ao nome da sua dependência. Quando os módulos são atualizados, eles são marcados com uma versão. O @ diz ao npm para procurar um sinalizador específico do módulo que você está instalando. Sem um sinalizador especificado, o npm instala a versão marcada mais recente. Abra o package.json novamente:

      Isso mostrará o seguinte:

      locator/package.json

      {
        "name": "locator",
        "version": "1.0.0",
        "description": "Finds the country of origin of the incoming request",
        "main": "index.js",
        "scripts": {
          "test": "echo "Error: no test specified" && exit 1"
        },
        "keywords": [
          "ip",
          "geo",
          "country"
        ],
        "author": "Sammy sammy@your_domain (https://your_domain)",
        "license": "ISC",
        "dependencies": {
          "axios": "^0.19.0"
        },
        "devDependencies": {
          "eslint": "^6.0.0"
        }
      }
      

      O eslint foi salvo como uma devDependencies, junto com o número da versão que você especificou mais cedo. Saia do package.json.

      Arquivos gerados automaticamente: node_modules e package-lock.json

      Quando você instala um pacote em um projeto do Node.js pela primeira vez, o npm cria automaticamente a pasta node_modules. Ela é usada para armazenar os módulos necessários para o seu projeto e o arquivo package-lock.json que você examinou mais cedo.

      Confirme que eles estão em seu diretório de trabalho. Em seu shell, digite ls e pressione ENTER. Você observará o seguinte resultado:

      Output

      node_modules package.json package-lock.json

      A pasta node_modules contém todas as dependências instaladas para o seu projeto. Na maioria dos casos, você não deve enviar essa pasta em seu repositório controlado por versão. Conforme instala mais dependências, o tamanho dessa pasta crescerá rapidamente. Além disso, o arquivo package-lock.json mantém um registro das versões exatas instaladas de uma maneira mais sucinta. Assim, incluir o node_modules não é necessário.

      Enquanto o arquivo package.json lista as dependências que nos informam as versões adequadas que devem ser instaladas para o projeto, o arquivo package-lock.json acompanha todas as alterações no package.json ou node_modules e nos informa a versão exata do pacote instalado. Normalmente, você envia isso para seu repositório controlado por versão, ao invés do node_modules, pois é uma representação mais clara de todas as suas dependências.

      Como instalar a partir do package.json

      Usando seus arquivos package.json e package-lock.json, você consegue configurar rapidamente as mesmas dependências de projeto antes de iniciar o desenvolvimento de um novo projeto. Para demonstrar isso, suba um nível em sua árvore de diretórios e crie uma nova pasta chamada cloned_locator no mesmo nível de diretório que o locator:

      • cd ..
      • mkdir cloned_locator

      Vá para seu novo diretório:

      Agora, copie os arquivos package.json e package-lock.json da pasta locator para cloned_locator:

      • cp ../locator/package.json ../locator/package-lock.json .

      Para instalar os módulos necessários para este projeto, digite:

      O npm verificará se há um arquivo package-lock.json para instalar os módulos. Caso nenhum arquivo lock esteja disponível, ele leria a partir do arquivo package.json para determinar as instalações. Normalmente, é mais rápido instalar a partir do package-lock.json, pois o arquivo lock contém a versão exata dos módulos e suas dependências. Isso significa que o npm não precisa gastar tempo para descobrir uma versão adequada para instalar.

      Ao implantar para a produção, pode ser que queira ignorar as dependências de desenvolvimento. Lembre-se que as dependências de desenvolvimento são armazenadas na seção devDependencies do package.json e não têm impacto na execução do seu aplicativo. Ao instalar módulos como parte do processo CI/CD para implantar o seu aplicativo, omita as dependências de desenvolvimento, executando:

      O sinalizador --production ignora a seção devDependencies durante a instalação. Por enquanto, permaneça com sua compilação de desenvolvimento.

      Antes de ir para a seção seguinte, volte para a pasta locator:

      Instalações globais

      Até agora, você esteve instalando os módulos npm para o projeto locator. O npm também permite que você instale pacotes globalmente. Isso significa que o pacote está disponível para seu usuário no sistema como um todo, assim como qualquer outro comando do shell . Essa habilidade é útil para os muitos módulos do Node.js que são ferramentas CLI.

      Por exemplo, pode ser que queira fazer postagens em blog sobre o projeto locator no qual você está trabalhando atualmente. Para fazer isso, utilize uma biblioteca como o Hexo para criar e gerenciar seu site de blog estático. Instale o Hexo CLI globalmente, desta forma:

      Para instalar um pacote globalmente, você adiciona o sinalizador -g ao comando.

      Nota: se receber um erro de permissão ao tentar instalar este pacote globalmente, seu sistema pode exigir privilégios de super-usuário para executar o comando. Tente novamente com sudo npm i hexo-cli -g.

      Teste se o pacote foi instalado com sucesso, digitando:

      Você verá um resultado semelhante a:

      Output

      hexo-cli: 2.0.0 os: Linux 4.15.0-64-generic linux x64 http_parser: 2.7.1 node: 10.14.0 v8: 7.6.303.29-node.16 uv: 1.31.0 zlib: 1.2.11 ares: 1.15.0 modules: 72 nghttp2: 1.39.2 openssl: 1.1.1c brotli: 1.0.7 napi: 4 llhttp: 1.1.4 icu: 64.2 unicode: 12.1 cldr: 35.1 tz: 2019a

      Até agora, você aprendeu como instalar os módulos com o npm. É possível instalar os pacotes em um projeto localmente, seja como uma dependência de produção ou de desenvolvimento. Você também pode instalar pacotes com base nos arquivos package.json ou package-lock.json pré-existentes, permitindo que desenvolva com as mesmas dependências que seus pares. Por fim, você pode utilizar o sinalizador -g para instalar os pacotes globalmente. Assim, você pode acessá-los independentemente se estiver em um projeto Node.js, ou não.

      Agora que você é capaz de instalar os módulos, na seção seguinte, você praticará técnicas para administrar suas dependências.

      Passo 3 — Gerenciando módulos

      Um gerenciador de pacotes completo pode fazer muito mais do que instalar módulos. O npm possui mais de 20 comandos relacionados ao gerenciamento de dependências disponível. Neste passo, você irá:

      • Listar módulos que já instalou.
      • Atualizar módulos para uma versão mais recente.
      • Desinstalar módulos que você já não precisa mais.
      • Executar uma auditoria de segurança em seus módulos para encontrar e corrigir falhas de segurança.

      Embora esses exemplos sejam feitos em sua pasta locator, todos esses comandos podem ser executados globalmente, adicionando o sinalizador -g no final deles, exatamente como você fez quando instalou globalmente.

      Como listar módulos

      Caso queira saber quais módulos estão instalados em um projeto, é mais fácil usar uma list (lista), ou ls, ao invés de ler o package.json diretamente. Para fazer isso, digite:

      Você verá um resultado como este:

      Output

      ├─┬ axios@0.19.0 │ ├─┬ follow-redirects@1.5.10 │ │ └─┬ debug@3.1.0 │ │ └── ms@2.0.0 │ └── is-buffer@2.0.3 └─┬ eslint@6.0.0 ├─┬ @babel/code-frame@7.5.5 │ └─┬ @babel/highlight@7.5.0 │ ├── chalk@2.4.2 deduped │ ├── esutils@2.0.3 deduped │ └── js-tokens@4.0.0 ├─┬ ajv@6.10.2 │ ├── fast-deep-equal@2.0.1 │ ├── fast-json-stable-stringify@2.0.0 │ ├── json-schema-traverse@0.4.1 │ └─┬ uri-js@4.2.2 ...

      Por padrão, o ls mostra toda a árvore de dependências — os módulos dos quais seu projeto depende e os módulos dos quais suas dependências dependem. Isso pode ser um pouco complicado caso queira um panorama de alto nível sobre o que está instalado.

      Para imprimir apenas os módulos que você instalou, sem as suas dependências, digite o seguinte em seu shell:

      O resultado será:

      Output

      ├── axios@0.19.0 └── eslint@6.0.0

      A opção --depth permite que você especifique qual nível da árvore de dependências quer usar. Quando ele é 0, você verá apenas suas dependências de nível superior.

      Como atualizar módulos

      É uma boa prática manter seus módulos do npm atualizados. Isso melhora sua probabilidade de obter os ajustes de segurança mais recentes para um módulo. Use o comando outdated para verificar se algum módulo pode ser atualizado:

      Você receberá um resultado como o seguinte:

      Output

      Package Current Wanted Latest Location eslint 6.0.0 6.7.1 6.7.1 locator

      Este comando lista primeiro o Package (pacote) que está instalado e a versão Current (atual). A coluna WANTED mostra qual versão satisfaz sua exigência de versão no package.json. A coluna Latest mostra a versão mais recente publicada do módulo.

      A coluna Location declara onde o pacote está localizado na árvore de dependências. O comando outdated tem o sinalizador --depth, assim como ls. Por padrão, o depth é 0.

      Parece que você pode atualizar o eslint para uma versão mais recente. Use o comando update ou up, desta forma:

      O resultado do comando incluirá a versão instalada:

      Output

      npm WARN locator@1.0.0 No repository field. + eslint@6.7.1 added 7 packages from 3 contributors, removed 5 packages, updated 19 packages, moved 1 package and audited 184 packages in 5.818s found 0 vulnerabilities

      Caso quisesse atualizar todos os módulos de uma só vez, digitaria:

      Como excluir módulos

      O comando npm uninstall é capaz de remover módulos dos seus projetos. Isso significa que o módulo já não estará mais instalado na pasta node_modules. Além disso, ele também não será visto em seus arquivos package.json e package-lock.json.

      Remover dependências de um projeto é uma atividade normal no ciclo de desenvolvimento de software. Uma dependência pode não resolver o problema como anunciado, ou não fornecer uma experiência de desenvolvimento satisfatória. Nestes casos, é melhor desinstalar a dependência e compilar seu próprio módulo.

      Imagine que o axios não forneça a experiência de desenvolvimento que você gostaria de ter ao fazer solicitações HTTP. Desinstale o axios com o comando uninstall ou un, digitando:

      Seu resultado será parecido com este:

      Output

      npm WARN locator@1.0.0 No repository field. removed 5 packages and audited 176 packages in 1.488s found 0 vulnerabilities

      Ele não diz explicitamente que o axios foi removido. Para verificar se ele foi desinstalado, liste as dependências novamente:

      Agora, vemos que apenas o eslint está instalado:

      Output

      └── eslint@6.7.1

      Isso mostra que você desinstalou o pacote axios com sucesso.

      Como auditar módulos

      O npm fornece um comando audit (auditoria) para destacar possíveis riscos de segurança em suas dependências. Para ver a auditoria em ação, instale uma versão desatualizada do módulo de solicitação, executando o seguinte:

      Ao instalar essa versão desatualizada de request (solicitação), você notará um resultado semelhante ao seguinte:

      Output

      + request@2.60.0 added 54 packages from 49 contributors and audited 243 packages in 7.26s found 6 moderate severity vulnerabilities run `npm audit fix` to fix them, or `npm audit` for details

      O npm está dizendo que você tem vulnerabilidades em suas dependências. Para obter mais detalhes, faça a auditoria em todo o seu projeto com:

      O comando audit mostra tabelas resultantes destacando falhas de segurança:

      Output

      === npm audit security report === # Run npm install request@2.88.0 to resolve 1 vulnerability ┌───────────────┬──────────────────────────────────────────────────────────────┐ │ Moderate │ Memory Exposure │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Package │ tunnel-agent │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Dependency of │ request │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Path │ request > tunnel-agent │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ More info │ https://npmjs.com/advisories/598 │ └───────────────┴──────────────────────────────────────────────────────────────┘ # Run npm update request --depth 1 to resolve 1 vulnerability ┌───────────────┬──────────────────────────────────────────────────────────────┐ │ Moderate │ Remote Memory Exposure │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Package │ request │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Dependency of │ request │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ Path │ request │ ├───────────────┼──────────────────────────────────────────────────────────────┤ │ More info │ https://npmjs.com/advisories/309 │ └───────────────┴──────────────────────────────────────────────────────────────┘ ...

      É possível ver o caminho da vulnerabilidade e, às vezes, o npm oferece maneiras para corrigi-la. Você pode executar o comando de atualização como sugerido, ou executar o subcomando fix do audit. Em seu shell, digite:

      Você verá um resultado semelhante a:

      Output

      + request@2.88.0 added 19 packages from 24 contributors, removed 32 packages and updated 12 packages in 6.223s fixed 2 of 6 vulnerabilities in 243 scanned packages 4 vulnerabilities required manual review and could not be updated

      O npm conseguiu atualizar com segurança dois dos pacotes, diminuindo suas vulnerabilidades na mesma medida. No entanto, você ainda tem quatro vulnerabilidades em suas dependências. O comando audit fix nem sempre conserta todos os problemas. Uma versão de um módulo pode ter uma vulnerabilidade de segurança. Entretanto, caso você atualize ela para uma versão com uma API diferente, isso poderia causar uma quebra do código mais elevado na árvore de dependências.

      Você pode utilizar o parâmetro --force para garantir que as vulnerabilidades se foram, desta forma:

      Como mencionado anteriormente, isso não é recomendado, a menos que tenha certeza de que ela não quebrará a funcionalidade do código.

      Conclusão

      Neste tutorial, você passou por vários exercícios para demonstrar que os módulos do Node.js são organizados em pacotes, e como esses pacotes são gerenciados pelo npm. Em um projeto do Node.js, você usou pacotes do npm como dependências. Fez isso através da criação e manutenção de um arquivo package.json — um registro dos metadados do seu projeto, incluindo quais módulos foram instalados. Você também usou a ferramenta CLI do npm para instalar, atualizar e remover módulos. Além disso, listou a árvore de dependências dos seus projetos e verificou e atualizou módulos desatualizados.

      No futuro, potencializar o código existente, usando módulos, irá acelerar o tempo de desenvolvimento, pois faz com que não precise repetir a funcionalidade. Você também conseguirá criar seus próprios módulos do npm. Estes serão gerenciados por outros via comandos do npm. Caso deseje continuar, faça um teste com o que você aprendeu neste tutorial, instalando e testando a grande variedade dos pacotes existentes. Veja o que o ecossistema proporciona para facilitar a solução do problemas. Por exemplo, você poderia testar o TypeScript, um superconjunto do JavaScript, ou transformar seu site em aplicativos móveis com o Cordova. Caso queira aprender mais sobre o Node.js, consulte nossos outros tutoriais do Node.js.



      Source link