C'è un modo per ottenere la versione da package.json nel codice nodejs?

C'è un modo per ottenere la versione impostata in package.jsonun'app nodejs? Vorrei qualcosa di simile

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

Ho scoperto che il seguente frammento di codice ha funzionato meglio per me. Dal momento che utilizza requireper caricare il package.json, funziona indipendentemente dalla directory di lavoro corrente.

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

Un avvertimento, per gentile concessione di @Pathogen:

Farlo con Browserify ha implicazioni per la sicurezza.
Fare attenzione a non esporre il proprio package.jsonclient, poiché significa che tutti i numeri di versione delle dipendenze, i comandi di creazione e test e altro vengono inviati al client.
Se stai costruendo server e client nello stesso progetto, esponi anche i tuoi numeri di versione sul lato server. Tali dati specifici possono essere utilizzati da un utente malintenzionato per adattarsi meglio all'attacco sul server.

Se l'applicazione viene avviata con 'npm start', puoi semplicemente utilizzare:

process.env.npm_package_version

Vedi package.json vars per maggiori dettagli.

Utilizzando i moduli ES6 è possibile effettuare le seguenti operazioni:

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

O in semplice vecchia conchiglia:

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

Questo può essere abbreviato in

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

Anche se questa non è esattamente la domanda posta, è utile se si desidera utilizzare la versione al package.jsonsuo interno , ad esempio per accedere a un file con versione in 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",
  ...
}

Esistono due modi per recuperare la versione:

1. Richiesta package.jsone richiesta della versione:

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

2. Utilizzando le variabili di ambiente:

const version = process.env.npm_package_version;

Si prega di non usare JSON.parse, fs.readFile, fs.readFileSynce non utilizzare un altro npm modulesnon è necessario per questa domanda.

Ecco come leggere la versione da package.json:

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

Esiste un altro modo per recuperare determinate informazioni dal package.jsonfile, in particolare utilizzando il modulo pkginfo .

L'uso di questo modulo è molto semplice. Puoi ottenere tutte le variabili del pacchetto usando:

require('pkginfo')(module);

O solo alcuni dettagli ( versionin questo caso)

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

E le variabili del pacchetto verranno impostate su module.exports(quindi il numero di versione sarà accessibile tramitemodule.exports.version ).

Puoi utilizzare il seguente frammento di codice:

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

Questo modulo ha una funzione molto bella: può essere utilizzato in qualsiasi file del progetto (ad es. Nelle sottocartelle) e recupererà automaticamente le informazioni dal tuo package.json. Quindi non devi preoccuparti dovepackage.json .

Spero che possa essere d'aiuto.

Per chi cerca una cassaforte sul lato client che funzioni anche sul lato server, c'è genversion . Si tratta di uno strumento da riga di comando che legge la versione dal package.json più vicino e genera un file di modulo CommonJS importabile che esporta la versione. Disclaimer: sono un manutentore.

$ genversion lib/version.js

Riconosco che la sicurezza lato client non era l'intenzione primaria di OP, ma come discusso nelle risposte di Mark Wallace e agosto , è molto rilevante e anche il motivo per cui ho trovato queste domande e risposte .

Sto solo aggiungendo una risposta perché sono arrivato a questa domanda per vedere il modo migliore per includere la versione da package.json nella mia applicazione web.

So che questa domanda è indirizzata a Node.js, tuttavia, se stai utilizzando Webpack per raggruppare la tua app solo un promemoria il modo consigliato è utilizzare DefinePlugin per dichiarare una versione globale nella configurazione e fare riferimento a ciò. Quindi potresti fare nel tuowebpack.config.json

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

...

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

E quindi AppVersionora è un globale che è disponibile per l'uso. Inoltre, assicurati .eslintrcdi ignorarlo tramite l'elica globale

opzione 1

La migliore pratica è la versione da package.json utilizzando le variabili di ambiente npm.

process.env.npm_package_version

maggiori informazioni su: https://docs.npmjs.com/using-npm/config.html

Funzionerà solo quando avvierai il tuo servizio usando il comando NPM.

Informazioni rapide: puoi leggere qualsiasi valore in pacakge.json usando process.env.npm_package_ [nome chiave]

opzione 2

Impostazione della versione nella variabile di ambiente utilizzando https://www.npmjs.com/package/dotenv come .envfile e relativa aprocess.env.version

È possibile utilizzare ES6 per importare package.json per recuperare il numero di versione e generare la versione sulla console.

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

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

Per determinare la versione del pacchetto nel codice nodo, è possibile utilizzare quanto segue:

1. const version = require('./package.json').version; per <versioni ES6

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

3. const version = process.env.npm_package_version; se l'applicazione è stata avviata utilizzando npm start, tutte le variabili d'ambiente npm_ * diventano disponibili.

4. Puoi usare anche i seguenti pacchetti npm: root-request, pkginfo, project-version.

È possibile utilizzare il pacchetto versione del progetto .

$ npm install --save project-version

Poi

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

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

Utilizza process.env.npm_package_versionma fallback sulla versione scritta package.jsonnel caso in cui env var sia mancante per qualche motivo.

Perché non usare la risoluzione richiesta ...

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

Con questo approccio funziona per tutti i percorsi secondari :)

Lo faccio con findup-sync:

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

So che questo non è l'intento del PO, ma dovevo solo farlo, quindi spero che aiuti la persona successiva.

Se stai usando docker-compose per il tuo processo CI / CD, puoi farlo in questo modo!

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', '')\""

per l'immagine, è possibile utilizzare qualsiasi immagine di nodo. Uso alpino perché è il più piccolo.

Importa il tuo package.jsonfile nel tuo server.jso app.jse poi accedi alle proprietà package.json nel file del server.

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

La variabile pacchetto contiene tutti i dati in package.json.

Ho creato un codice utile per ottenere il package.json del modulo genitore

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
}

Se si utilizza il rollup, il rollup-plugin-replaceplug-in può essere utilizzato per aggiungere la versione senza esporre package.json al 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
    }),
  ]
};

Quindi, nel codice sorgente, ovunque si desideri avere la versione package.json, si utilizzerà la stringa "MY_PACKAGE_JSON_VERSION".

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