Existe uma maneira de obter a versão do package.json no código nodejs?

Existe uma maneira de obter a versão definida package.jsonem um aplicativo nodejs? Eu gostaria de algo assim

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

Eu descobri que o seguinte fragmento de código funcionou melhor para mim. Como ele usa requirepara carregar o package.json, ele funciona independentemente do diretório de trabalho atual.

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

Um aviso, cortesia de @Pathogen:

Fazer isso com o Browserify tem implicações de segurança.
Cuidado para não expor o seu package.jsonao cliente, pois isso significa que todos os números de versão da sua dependência, comandos de compilação e teste e muito mais são enviados ao cliente.
Se você estiver criando servidor e cliente no mesmo projeto, também expõe seus números de versão do servidor. Esses dados específicos podem ser usados ​​por um invasor para melhor se adequar ao ataque ao seu servidor.

Se seu aplicativo for iniciado com 'npm start', você pode simplesmente usar:

process.env.npm_package_version

Veja package.json vars para mais detalhes.

Usando os módulos ES6, você pode fazer o seguinte:

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

Ou em concha velha lisa:

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

Isso pode ser reduzido para

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

Mesmo que essa não seja exatamente a pergunta, é útil se você quiser usar a versão em package.jsonsi mesma, por exemplo, para fazer logon em um arquivo com versão em 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",
  ...
}

Existem duas maneiras de recuperar a versão:

1. Exigindo package.jsone obtendo a versão:

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

2. Usando as variáveis ​​de ambiente:

const version = process.env.npm_package_version;

Por favor, não use JSON.parse, fs.readFile, fs.readFileSynce não use outra npm modulesque não é necessário para esta pergunta.

Aqui está como ler a versão do package.json:

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

Existe outra maneira de buscar certas informações do seu package.jsonarquivo, usando o módulo pkginfo .

O uso deste módulo é muito simples. Você pode obter todas as variáveis ​​de pacote usando:

require('pkginfo')(module);

Ou apenas alguns detalhes ( versionneste caso)

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

E suas variáveis ​​de pacote serão definidas como module.exports(para que o número da versão seja acessível viamodule.exports.version ).

Você pode usar o seguinte trecho de código:

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

Este módulo possui um recurso muito interessante - ele pode ser usado em qualquer arquivo do seu projeto (por exemplo, em subpastas) e buscará automaticamente as informações do seu projeto. package.json . Então você não precisa se preocupar onde package.jsonestá.

Espero que ajude.

Para aqueles que procuram uma solução segura do lado do cliente que também funcione no lado do servidor, existe uma genversão . É uma ferramenta de linha de comando que lê a versão do package.json mais próximo e gera um arquivo de módulo CommonJS importável que exporta a versão. Disclaimer: Eu sou um mantenedor.

$ genversion lib/version.js

Reconheço que a segurança do cliente não era a intenção principal do OP, mas, como discutido nas respostas de Mark Wallace e agosto , é altamente relevante e também o motivo pelo qual encontrei essas perguntas e respostas.

Apenas adicionando uma resposta porque cheguei a esta pergunta para ver a melhor maneira de incluir a versão do package.json no meu aplicativo da web.

Sei que esta pergunta é direcionada para o Node.js, no entanto, se você estiver usando o Webpack para agrupar seu aplicativo, apenas um lembrete, a maneira recomendada é usar o DefinePlugin para declarar uma versão global na configuração e fazer referência a isso. Então você poderia fazer no seuwebpack.config.json

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

...

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

E AppVersionagora é um global que está disponível para você usar. Também certifique-se de que .eslintrcvocê ignora isso através do suporte global

Opção 1

A melhor prática é fazer a versão do package.json usando variáveis ​​de ambiente npm.

process.env.npm_package_version

mais informações em: https://docs.npmjs.com/using-npm/config.html

Isso funcionará apenas quando você iniciar o serviço usando o comando NPM.

Informações rápidas: você pode ler quaisquer valores no pacakge.json usando process.env.npm_package_ [keyname]

opção 2

Configurando a versão na variável de ambiente usando https://www.npmjs.com/package/dotenv como .envarquivo e em relação aprocess.env.version

Você pode usar o ES6 para importar o package.json para recuperar o número da versão e gerar a versão no console.

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

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

Para determinar a versão do pacote no código do nó, você pode usar o seguinte:

1. const version = require('./package.json').version; para <versões ES6

2. import {version} from './package.json'; para versão ES6

3. const version = process.env.npm_package_version; se o aplicativo foi iniciado npm start, todas as variáveis ​​de ambiente npm_ * ficam disponíveis.

4. Você também pode usar os seguintes pacotes npm - root-require, pkginfo, project-version.

Você pode usar o pacote de versão do projeto .

$ npm install --save project-version

Então

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

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

Ele usa process.env.npm_package_versionmas fallback na versão escrita package.jsonno caso do env var estar ausente por algum motivo.

Por que não usar a resolução requerida ...

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

Com essa abordagem, trabalhe para todos os subcaminhos :)

Eu faço isso com findup-sync:

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

Sei que essa não é a intenção do OP, mas eu apenas precisei fazer isso, por isso espero que ajude a próxima pessoa.

Se você estiver usando o docker-composite para o seu processo de CI / CD, poderá obtê-lo dessa maneira!

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

para a imagem, você pode usar qualquer imagem de nó. Eu uso alpino porque é o menor.

Importar seu package.jsonarquivo em seu server.jsou app.jse, em seguida, propriedades de acesso package.json em arquivos do servidor.

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

A variável package contém todos os dados em package.json.

Criei um código útil para obter o package.json do módulo pai

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 estiver usando rollup, o rollup-plugin-replaceplug - in pode ser usado para adicionar a versão sem expor package.json ao cliente.

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

Em seguida, no código-fonte, em qualquer lugar onde você deseja ter a versão package.json, você usaria a string 'MY_PACKAGE_JSON_VERSION'.

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