Czy istnieje sposób na uzyskanie wersji z package.json w kodzie nodejs?

Czy istnieje sposób na ustawienie wersji w package.jsonaplikacji nodejs? Chciałbym czegoś takiego

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

Odkryłem, że następujący fragment kodu działa najlepiej dla mnie. Ponieważ używa requiredo ładowania package.json, działa niezależnie od bieżącego katalogu roboczego.

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

Ostrzeżenie, dzięki uprzejmości @Pathogen:

Robienie tego za pomocą Browserify ma wpływ na bezpieczeństwo.
Uważaj, aby nie ujawnić swojego package.jsonklienta, ponieważ oznacza to, że wszystkie numery wersji zależności, polecenia kompilacji i testowania oraz inne są wysyłane do klienta.
Jeśli budujesz serwer i klienta w tym samym projekcie, ujawniasz również numery wersji po stronie serwera. Takie określone dane mogą być wykorzystane przez atakującego, aby lepiej dopasować atak do twojego serwera.

Jeśli twoja aplikacja jest uruchomiona z „npm start”, możesz po prostu użyć:

process.env.npm_package_version

Aby uzyskać więcej informacji, zobacz vars package.json .

Za pomocą modułów ES6 możesz wykonać następujące czynności:

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

Lub w zwykłej starej powłoce:

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

Można to skrócić

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

Chociaż nie jest to dokładnie to, o co pytano, jest przydatne, jeśli chcesz użyć wersji w package.jsonsobie, na przykład zalogować się do pliku w wersji w 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",
  ...
}

Istnieją dwa sposoby pobrania wersji:

1. Wymaganie package.jsoni uzyskanie wersji:

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

2. Korzystanie ze zmiennych środowiskowych:

const version = process.env.npm_package_version;

Proszę nie używać JSON.parse, fs.readFile, fs.readFileSynci nie używać innego npm modulesnie jest to konieczne dla tej kwestii.

Oto jak odczytać wersję z pliku package.json:

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

Istnieje inny sposób pobierania niektórych informacji z package.jsonpliku, a mianowicie użycie modułu pkginfo .

Korzystanie z tego modułu jest bardzo proste. Możesz pobrać wszystkie zmienne pakietu, używając:

require('pkginfo')(module);

Lub tylko niektóre szczegóły ( versionw tym przypadku)

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

Zmienne pakietu zostaną ustawione na module.exports(więc numer wersji będzie dostępny za pośrednictwem module.exports.version).

Możesz użyć następującego fragmentu kodu:

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

Moduł ma bardzo fajną funkcję - można go użyć w dowolnym pliku w projekcie (np. W podfolderach) i automatycznie pobierze informacje z twojego package.json. Więc nie musisz się martwić, gdzie jesteś package.json.

Mam nadzieję, że to pomoże.

Dla tych, którzy szukają bezpiecznego rozwiązania po stronie klienta , które działa również po stronie serwera, istnieje genversion . Jest to narzędzie wiersza polecenia, które odczytuje wersję z najbliższego package.json i generuje importowalny plik modułu CommonJS, który eksportuje wersję. Oświadczenie: Jestem opiekunem.

$ genversion lib/version.js

Uznaję bezpieczeństwo po stronie klienta nie był pierwotny zamiar OP, ale jak wspomniano w odpowiedzi przez Mark Wallace i sie , to jest bardzo istotne, a także powód Znalazłem Q & A.

Właśnie dodając odpowiedź, ponieważ przyszedłem do tego pytania, aby zobaczyć najlepszy sposób na dołączenie wersji z package.json do mojej aplikacji internetowej.

Wiem, że to pytanie jest skierowane do Node.js, ale jeśli używasz Webpacka do spakowania aplikacji jako przypomnienie, zalecanym sposobem jest użycie DefinePlugin do zadeklarowania wersji globalnej w konfiguracji i odwołanie się do tego. Więc możesz zrobić w swoimwebpack.config.json

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

...

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

A potem AppVersionjest teraz globalny, który jest dostępny do użycia. Upewnij się także, .eslintrcże zignorujesz to poprzez rekwizyt globals

opcja 1

Najlepszą praktyką jest wersja z package.json przy użyciu zmiennych środowiskowych npm.

process.env.npm_package_version

więcej informacji na: https://docs.npmjs.com/using-npm/config.html

Działa to tylko po uruchomieniu usługi za pomocą polecenia NPM.

Szybka informacja: możesz odczytać dowolne wartości w pacakge.json przy użyciu process.env.npm_package_ [nazwa klucza]

Opcja 2

Ustawianie wersji w zmiennej środowiskowej za pomocą https://www.npmjs.com/package/dotenv jako .envpliku i uwzględnianie jej wprocess.env.version

Za pomocą ES6 można zaimportować pakiet.json w celu pobrania numeru wersji i wypisania wersji na konsolę.

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

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

Aby ustalić wersję pakietu w kodzie węzła, możesz użyć następujących opcji:

1. const version = require('./package.json').version; dla wersji <ES6

2. import {version} from './package.json'; dla wersji ES6

3. const version = process.env.npm_package_version; jeśli aplikacja została uruchomiona przy użyciu npm start, wszystkie zmienne środowiskowe npm_ * stają się dostępne.

4. Możesz także użyć następujących pakietów npm - root-demand, pkginfo, wersja projektu.

Możesz użyć pakietu wersji projektu .

$ npm install --save project-version

Następnie

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

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

Używa, process.env.npm_package_versionale zastępuje wersję napisaną package.jsonw przypadku, gdy z jakiegoś powodu brakuje zmiennej env var.

Robię to z findup-sync:

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

Wiem, że to nie jest cel PO, ale musiałem to zrobić, więc mam nadzieję, że pomoże to następnej osobie.

Jeśli używasz komponowania dokującego do procesu CI / CD, możesz to zrobić w ten sposób!

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

dla obrazu możesz użyć dowolnego obrazu węzła. Używam alpine, ponieważ jest najmniejsza.

Dlaczego nie użyć wymagającego rozwiązania ...

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

Dzięki takiemu podejściu działa dla wszystkich ścieżek podrzędnych :)

Zaimportuj package.jsonplik do pliku server.jslub, app.jsa następnie uzyskaj dostęp do właściwości package.json do pliku serwera.

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

zmienna pakietu zawiera wszystkie dane w pliku package.json.

Zrobiłem użyteczny kod, aby uzyskać pakiet.json modułu nadrzędnego

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
}

Jeśli używasz pakietu zbiorczego, rollup-plugin-replacewtyczki można użyć do dodania wersji bez ujawniania pliku package.json klientowi.

// 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
    }),
  ]
};

Następnie w kodzie źródłowym, gdziekolwiek chcesz mieć wersję package.json, użyjesz ciągu „MY_PACKAGE_JSON_VERSION”.

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