Existe-t-il un moyen d'obtenir la version de package.json dans le code nodejs?

Existe-t-il un moyen d'obtenir la version définie package.jsondans une application nodejs? Je voudrais quelque chose comme ça

var port = process.env.PORT || 3000
app.listen port
console.log "Express server listening on port %d in %s mode %s", app.address().port, app.settings.env, app.VERSION

J'ai trouvé que le fragment de code suivant fonctionnait le mieux pour moi. Puisqu'il utilise requirepour charger le package.json, il fonctionne quel que soit le répertoire de travail actuel.

var pjson = require('./package.json');
console.log(pjson.version);

Un avertissement, gracieuseté de @Pathogen:

Faire cela avec Browserify a des implications de sécurité.
Veillez à ne pas exposer votre package.jsonau client, car cela signifie que tous vos numéros de version de dépendance, les commandes de génération et de test et plus sont envoyés au client.
Si vous créez un serveur et un client dans le même projet, vous exposez également vos numéros de version côté serveur. Ces données spécifiques peuvent être utilisées par un attaquant pour mieux adapter l'attaque sur votre serveur.

Si votre application est lancée avec 'npm start', vous pouvez simplement utiliser:

process.env.npm_package_version

Voir package.json vars pour plus de détails.

À l'aide des modules ES6, vous pouvez effectuer les opérations suivantes:

import {version} from './package.json';

Ou en plaine ancienne:

node -e "console.log(require('./package.json').version);"

Cela peut être raccourci

node -p "require('./package.json').version"

Même si ce n'est pas exactement la question posée, c'est utile si vous voulez utiliser la version en package.jsonelle-même, par exemple pour vous connecter à un fichier versionné dans un script:

{
  "name": "myapp",
  "version": "0.1.2",
  "scripts": {
    "run": "node index.js 2>&1 | tee -a myapp_v$(node -p \"require('./package.json').version\").log",
  ...
}

Il existe deux façons de récupérer la version:

1. Exiger package.jsonet obtenir la version:

const { version } = require('./package.json');

2. Utilisation des variables d'environnement:

const version = process.env.npm_package_version;

S'il vous plaît ne pas utiliser JSON.parse, fs.readFile, fs.readFileSyncet ne pas utiliser une autre , npm modulesil est pas nécessaire pour cette question.

Voici comment lire la version de package.json:

fs = require('fs')
json = JSON.parse(fs.readFileSync('package.json', 'utf8'))
version = json.version

Il existe une autre façon de récupérer certaines informations de votre package.jsonfichier, à savoir en utilisant le module pkginfo .

L'utilisation de ce module est très simple. Vous pouvez obtenir toutes les variables de package en utilisant:

require('pkginfo')(module);

Ou seulement certains détails ( versiondans ce cas)

require('pkginfo')(module, 'version');

Et vos variables de package seront définies sur module.exports(donc le numéro de version sera accessible via module.exports.version).

Vous pouvez utiliser l'extrait de code suivant:

require('pkginfo')(module, 'version');
console.log "Express server listening on port %d in %s mode %s", app.address().port, app.settings.env, module.exports.version

Ce module a une fonctionnalité très intéressante - il peut être utilisé dans n'importe quel fichier de votre projet (par exemple dans les sous-dossiers) et il récupérera automatiquement les informations de votre package.json. Vous n'avez donc pas à vous soucier où vous êtes package.json.

J'espère que cela aidera.

Pour ceux qui recherchent une solution côté client sûre qui fonctionne également côté serveur, il y a genversion . Il s'agit d'un outil en ligne de commande qui lit la version à partir du package.json le plus proche et génère un fichier de module CommonJS importable qui exporte la version. Avertissement: je suis un mainteneur.

$ genversion lib/version.js

Je reconnais que la sécurité côté client n'était pas l'intention principale d'OP, mais comme discuté dans les réponses de Mark Wallace et août , c'est très pertinent et c'est aussi la raison pour laquelle j'ai trouvé ce Q&R.

Je viens d'ajouter une réponse parce que je suis venu à cette question pour voir la meilleure façon d'inclure la version de package.json dans mon application Web.

Je sais que cette question est ciblée pour Node.js cependant, si vous utilisez Webpack pour regrouper votre application, juste un rappel, la méthode recommandée consiste à utiliser DefinePlugin pour déclarer une version globale dans la configuration et la référencer. Vous pourriez donc faire dans votrewebpack.config.json

const pkg = require('../../package.json');

...

plugins : [
    new webpack.DefinePlugin({
      AppVersion: JSON.stringify(pkg.version),
...

Et puis AppVersionest maintenant un global qui est disponible pour vous d'utiliser. Assurez- vous également que .eslintrcvous l'ignorez via l'accessoire global

Option 1

La meilleure pratique consiste à effectuer une version à partir de package.json à l'aide des variables d'environnement npm.

process.env.npm_package_version

plus d'informations sur: https://docs.npmjs.com/using-npm/config.html

Cela ne fonctionnera que lorsque vous démarrez votre service à l'aide de la commande NPM.

Info rapide: vous pouvez lire toutes les valeurs dans pacakge.json en utilisant process.env.npm_package_ [nom de clé]

Option 2

Définition de la version dans la variable d'environnement en utilisant https://www.npmjs.com/package/dotenv en tant que .envfichier et en la considérant dansprocess.env.version

Vous pouvez utiliser ES6 pour importer package.json pour récupérer le numéro de version et sortir la version sur la console.

import {name as app_name, version as app_version}  from './path/to/package.json';

console.log(`App ---- ${app_name}\nVersion ---- ${app_version}`);

Pour déterminer la version du package dans le code de nœud, vous pouvez utiliser les éléments suivants:

1. const version = require('./package.json').version; pour <versions ES6

2. import {version} from './package.json'; pour la version ES6

3. const version = process.env.npm_package_version; si l'application a été démarrée à l'aide npm start, toutes les variables d'environnement npm_ * deviennent disponibles.

4. Vous pouvez également utiliser les packages npm suivants - root-require, pkginfo, project-version.

Vous pouvez utiliser le package de version projet .

$ npm install --save project-version

alors

const version = require('project-version');

console.log(version);
//=>  '1.0.0'

Il utilise process.env.npm_package_versionmais se replie sur la version écrite dans le package.jsoncas où la var env serait manquante pour une raison quelconque.

Pourquoi ne pas utiliser la résolution requise ...

const packageJson = path.dirname(require.resolve('package-name')) + '/package.json';
const { version } = require(packageJson);
console.log('version', version)

Avec cette approche, travaillez pour tous les sous-chemins :)

Je fais ça avec findup-sync:

var findup = require('findup-sync');
var packagejson = require(findup('package.json'));
console.log(packagejson.version); // => '0.0.1' 

Je sais que ce n'est pas l'intention du PO, mais je devais juste le faire, alors j'espère que cela aidera la prochaine personne.

Si vous utilisez docker-compose pour votre processus CI / CD, vous pouvez l'obtenir de cette façon!

version:
  image: node:7-alpine
  volumes:
    - .:/usr/src/service/
  working_dir: /usr/src/service/
  command: ash -c "node -p \"require('./package.json').version.replace('\n', '')\""

pour l'image, vous pouvez utiliser n'importe quelle image de nœud. J'utilise l'alpin car c'est le plus petit.

Importez votre package.jsonfichier dans votre server.jsou app.jspuis accédez aux propriétés package.json dans le fichier serveur.

var package = require('./package.json');

La variable de package contient toutes les données de package.json.

J'ai créé un code utile pour obtenir le package du module parent.json

function loadParentPackageJson() {
    if (!module.parent || !module.parent.filename) return null
    let dir = path.dirname(module.parent.filename)
    let maxDepth = 5
    let packageJson = null
    while (maxDepth > 0) {
        const packageJsonPath = `${dir}/package.json`
        const exists = existsSync(packageJsonPath)
        if (exists) {
            packageJson = require(packageJsonPath)
            break
        }
        dir = path.resolve(dir, '../')
        maxDepth--
    }
    return packageJson
}

Si vous utilisez le cumul, le rollup-plugin-replaceplug - in peut être utilisé pour ajouter la version sans exposer package.json au client.

// rollup.config.js

import pkg from './package.json';
import { terser } from "rollup-plugin-terser";
import resolve from 'rollup-plugin-node-resolve';
import commonJS from 'rollup-plugin-commonjs'
import replace from 'rollup-plugin-replace';

export default {
  plugins: [
    replace({
      exclude: 'node_modules/**',
      'MY_PACKAGE_JSON_VERSION': pkg.version, // will replace 'MY_PACKAGE_JSON_VERSION' with package.json version throughout source code
    }),
  ]
};

Ensuite, dans le code source, n'importe où où vous voulez avoir la version package.json, vous utiliseriez la chaîne 'MY_PACKAGE_JSON_VERSION'.

// src/index.js
export const packageVersion = 'MY_PACKAGE_JSON_VERSION' // replaced with actual version number in rollup.config.js