Boas práticas para criar um pacote npm moderno com segurança em mente

A tecnologia está sempre mudando, e seus processos e práticas precisam acompanhar essas mudanças. Por isso, embora o npm tenha 15 anos (em 2025), suas práticas de criação de pacotes npm esperamos que sejam bem mais modernas. Mas, se você desconfia que elas estejam um pouco desatualizadas, continue lendo.

Neste tutorial, vamos mostrar passo a passo como criar um pacote npm usando as melhores práticas atuais (em 2025). Primeiro, você vai aprender a criar um pacote npm e se familiarizar com a criação e publicação de um pacote no registro do npm. Depois, vai conhecer o que é necessário para criar um pacote npm mais robusto e pronto para produção, configurando uma estrutura de testes, um pipeline de integração e implantação contínuas, verificações de segurança e gerenciamento automatizado de versões semânticas para os lançamentos. Ao final deste tutorial, você terá confiança para criar pacotes npm modernos e sustentáveis. Vamos começar!

Pré-requisitos

1. Familiaridade com Node.js, JavaScript/TypeScript, GitHub e GitHub Actions

2. Ferramentas de desenvolvimento disponíveis para ajudar na criação de um pacote npm

Exemplo simples de pacote npm

Vamos primeiro conhecer o processo de criação e publicação de um pacote npm com um exemplo simples. Se você já conhece esse processo, pode ir direto à seção Pacote npm pronto para produção, que aborda tópicos mais avançados.

Configure seu projeto

Para começar, você precisará de um projeto no GitHub. Siga estas etapas para criar um. Se já tiver um projeto para usar, pode pular para a próxima seção, mas não deixe de conferir novamente a etapa 5 desta seção, sobre o nome do pacote.

• Crie um repositório no GitHub: https://github.com/new

• Clone o repositório localmente.
  Exemplo: git clone https://github.com/snyk-snippets/simple-npm-package.git

• Abra o terminal e navegue até a pasta do projeto que você clonou.
  Exemplo: cd simple-npm-package

• Execute npm init -y para criar um arquivo package.json. Observação: se você clonou o repositório de exemplo, não precisa fazer esta etapa.

• Atualize a propriedade name em package.json com um nome com escopo.
  Exemplo: @clarkio/simple-npm-package. Use seu nome de usuário ou o nome da sua organização no lugar de @clarkio.

• Escreva o código do pacote (ou use o exemplo hello world em index.js).

Depois de criar o projeto, você pode criar uma conta no npm.

Crie uma conta no npm

Para disponibilizar seu pacote npm para outras pessoas, você precisará de uma conta no npm. As etapas a seguir mostram como criar sua própria conta (caso ainda não tenha uma), ativar a autenticação de dois fatores (2FA) para aumentar a segurança da conta e conectá-la à sua máquina local.

1. Cadastre-se no npm em https://www.npmjs.com/signup. 

2. Para aumentar a segurança, ative a 2FA na sua conta do npm: https://docs.npmjs.com/configuring-two-factor-authentication. 

3. Entre na sua conta do npm pelo terminal usando o comando npm login e siga as instruções exibidas na tela. Por exemplo:

1> npm login
2npm notice Log in on https://registry.npmjs.org/
3Username: clarkio
4Password:
5Email: (this IS public) <email address>
6npm notice Please use the one-time password (OTP) from your authenticator application
7Enter one-time password from our authenticator app: <OTP>
8Logged in as clarkio on https://registry.npmjs.org/.

Como publicar seu pacote npm

Com um projeto e uma conta no npm, você já pode publicar seu pacote no registro público e oficial do npmjs para que outras pessoas possam usá-lo. Siga estas etapas para conferir o que será publicado antes de executar a publicação:

1. No terminal, execute npx pack --dry-run para ver o conteúdo que será incluído na versão publicada do pacote.

1> npx pack --dry-run
2npm notice Tarball Contents
3npm notice 1.1kB LICENSE
4npm notice 1.9kB README.md
5npm notice 108B index.js
6npm notice 700B package.json
7npm notice Tarball Details

Assim, você garante que não está deixando de incluir arquivos de código-fonte necessários para o funcionamento correto do pacote. Também é uma boa prática verificar se você não está expondo acidentalmente informações confidenciais ao público, como um arquivo de configuração local com credenciais de banco de dados ou chaves de API.

2. No terminal, execute npm publish --dry-run para ver o que aconteceria se você executasse o comando de verdade.

1> npm publish --dry-run
2npm notice
3npm notice 📦@clarkio/simple-npm-package@0.0.1
4npm notice === Tarball Contents ===
5npm notice 1.1kB LICENSE
6npm notice 1.2kB README.md
7npm notice 95B index.js
8npm notice 690B package.json
9npm notice === Tarball Details===
10npm notice name: @clarkio/simple-npm-package
11npm notice version: 0.0.1
12npm notice filename:@clarkio/simple-npm-package-0.0.1.tgz
13npm notice package size:1.7 kB
14npm notice unpacked size: 3.1 kB
15npm notice shasum:40ede3ed630fa8857c0c9b8d4c81664374aa811c
16npm notice integrity:sha512-QZCyWZTspkcUXL... ]L60ZKBOOBRLTg==
17npm notice total files:4
18npm notice
19+ @clarkio/simple-npm-package@0.0.1

3. No terminal, execute npm publish --access=public para publicar o pacote no npm. Observação: --access=public é necessário para pacotes com escopo (@clarkio/modern-npm-package), pois eles são privados por padrão. Se o pacote não tiver escopo e o campo private não estiver definido como true em package.json, ele também será público.

1> npm publish --access=public
2npm notice
3npm notice 📦@clarkio/simple-npm-package@0.0.1
4npm notice === Tarball Contents ===
5npm notice 1.1kB LICENSE
6npm notice 1.2kB README.md
7npm notice 95B index.js
8npm notice 690B package.json
9npm notice === Tarball Details===
10npm notice name: @clarkio/simple-npm-package
11npm notice version: 0.0.1
12npm notice filename:@clarkio/simple-npm-package-0.0.1.tgz
13npm notice package size:2.1 kB
14npm notice unpacked size: 4.1 kB
15npm notice shasum:6f335d6254ebb77a5a24ee729650052a69994594
16npm notice integrity:sha512-VZ1K1eMFOKeJW[...]7ZjKFVAxLcpdQ==
17npm notice total files:4
18npm notice
19This operation requires a one-time password.
20Enter OTP: <OTP>
21+ @clarkio/simple-npm-package@0.0.1

Pronto! Você criou e implantou seu próprio pacote npm. Agora, você vai aprender a criar um pacote mais robusto, pronto para ambientes de produção e para ser usado por mais pessoas.

Pacote npm pronto para produção

Embora o pacote de exemplo anterior possa ser usado em produção, sua manutenção ao longo do tempo exige trabalho manual. O uso de ferramentas e automação, junto com testes adequados e verificações de segurança, ajuda a reduzir o esforço total para manter o pacote funcionando sem problemas. Vamos entender melhor o que isso envolve.

As próximas seções abordarão:

1. Configurar seu projeto modern-npm-package

2. Compilar para o formato de módulos ECMAScript (ESM)

3. Configurar e escrever testes de unidade

4. Implementar verificações de segurança

5. Automatizar o gerenciamento de versões e a publicação

Se você não tiver um projeto próprio para acompanhar este artigo, use o projeto de exemplo a seguir como referência: https://github.com/snyk-snippets/modern-npm-package.

Compilação para o formato de módulos ECMAScript

O formato de módulos ECMAScript é compatível nativamente com o Node.js a partir da versão 12, e a versão mais recente com suporte de longo prazo é a 22.x. Além disso, há mais concorrência no ecossistema de runtimes JavaScript, com opções como Bun.js e Deno — todas facilitam o uso do formato ESM. Vamos usar TypeScript para preparar seu pacote npm para trabalhar com ESM.

• Primeiro, crie um arquivo de configuração do TypeScript chamado tsconfig.json. Ele define as opções de compilação que podem ser usadas ao criar seu pacote com ESM. Ajuste-o conforme necessário para seu projeto. Em especial, se não estiver usando o exemplo fornecido, você precisará ajustar a propriedade files para corresponder à estrutura do projeto.

1{
2    "compilerOptions": {
3      "lib": ["ES2024", "DOM"],
4      "target": "ES2024",
5      "module": "NodeNext",
6      "moduleResolution": "NodeNext",
7      "outDir": "./lib/",
8      "declarationDir": "./lib/types",
9      "strict": true,
10      "esModuleInterop": true,
11      "forceConsistentCasingInFileNames": true,
12      "skipLibCheck": true,
13      "checkJs": true,
14      "allowJs": true,
15      "declaration": true,
16      "declarationMap": true,
17      "allowSyntheticDefaultImports": true
18    },
19    "files": ["./src/index.ts"]
20  }

• A propriedade lib informa ao TypeScript quais tipos devem ser usados como referência enquanto você escreve o código do projeto.

• A propriedade target informa ao TypeScript para qual versão do JavaScript o código do projeto deve ser compilado.

• A propriedade module informa ao TypeScript qual formato de módulo JavaScript deve ser usado ao compilar o código do projeto.

• A propriedade moduleResolution ajuda o TypeScript a determinar como uma instrução “import” deve ser resolvida.

• As propriedades outDir e declarationDir indicam ao TypeScript onde colocar os resultados da compilação do código e as definições dos tipos usados nele.

2. Atualize o arquivo package.json com um campo files que aponte para a pasta lib, onde ficam os arquivos gerados pelo TypeScript durante a compilação do pacote.

3. Atualize os campos main e types do arquivo package.json para apontar para os arquivos de saída do pacote compilado. Eles funcionarão como opções padrão e de fallback.

1"types": "./lib/index.d.ts",
2  "main": "./lib/index.js",

4. Adicione um campo files ao arquivo package.json para indicar quais arquivos devem ser incluídos quando o npm empacotar seu código para publicação.

1"files": [
2   "lib/**/*"
3],

5. Crie comandos no campo scripts do package.json para usar o tsc e compilar o pacote. Isso vai gerar os arquivos de origem para a pasta lib.

1    "clean": "del-cli ./lib",
2    "build": "npm run clean && tsc -p ./tsconfig.json",
3    "prepack": "npm run build",

• O script clean exclui os arquivos de saída de compilações anteriores e começa do zero.

• O script build limpa os arquivos de saída anteriores e usa o compilador do TypeScript para compilar o pacote no diretório de saída.

• O script prepack é usado pelo npm antes de empacotar o pacote, como preparação para publicá-lo em um registro.

6. Agora, instale as dependências de desenvolvimento necessárias para que tudo funcione. Execute npm install -D typescript del-cli

7. Agora, execute npm run build no terminal para que o TypeScript compile seu projeto e o prepare para uso e publicação

Essa é toda a configuração necessária para usar o TypeScript na compilação do seu pacote npm, compatível com os formatos de módulos CommonJS e ECMAScript. Em seguida, você vai aprender a configurar e executar testes no código do pacote npm para garantir que ele gere os resultados esperados.

Configurando e adicionando testes

Para confiar no comportamento e nos resultados do seu código, você precisa implementar um processo de testes. Os testes levam você a pensar na funcionalidade do código de maneiras diferentes, além do caminho feliz típico ao criá-lo. Por exemplo, você pode pensar em formas de fazer uma função falhar, provocando um erro ou gerando um resultado inesperado. Isso torna sua aplicação mais resiliente e sustentável, além de garantir que nada pare de funcionar quando você adicionar novos recursos.

Se quiser se aprofundar em testes e conhecer as melhores práticas, leia o repositório de boas práticas de JavaScript de Yoni Goldberg.

Testes de unidade

Para garantir que seu pacote se comporte da maneira esperada, você precisa escrever testes para o código. Algumas ferramentas ajudam a configurar o projeto para executar testes de unidade e exibir os resultados. Agora, essas ferramentas estão disponíveis como módulos integrados no Node.js (desde as versões 20.x, 18.x e 16.17.x, nesta última por meio de uma flag experimental). Siga as etapas abaixo para configurar e executar testes no seu pacote npm:

1.  Instale as dependências de desenvolvimento usando este comando no terminal: npm i -D @types/node

2. Crie uma pasta tests no diretório raiz do projeto.

3. Crie um arquivo index.test.ts na pasta tests.

4. Escreva testes de unidade no arquivo index.test.ts para testar o código em index.ts

Observação: você pode usar como exemplo o repositório do pacote npm: https://github.com/snyk-snippets/modern-npm-package.

5. Adicione a propriedade tests à seção scripts do arquivo package.json e atribua a ela o valor node --experimental-strip-types --test

1  "scripts": {
2     "clean": "del-cli ./lib",
3    "build": "npm run clean && tsc -p ./tsconfig.json",
4    "prepack": "npm run build",
5    "test": "node --experimental-strip-types --test",
6
7  },

6. No terminal, a partir da pasta raiz do projeto, execute npm test para rodar os testes e ver os resultados:

1> @snyk-labs/modern-npm-package@0.0.0-development test
2> node --experimental-strip-types --test
3
4(node:83429) ExperimentalWarning: Type Stripping is an experimental feature and might change at any time
5(Use `node --trace-warnings ...` to show where the warning was created)
6(node:83430) ExperimentalWarning: Type Stripping is an experimental feature and might change at any time
7(Use `node --trace-warnings ...` to show where the warning was created)
8▶ NPM Package
9  ✔ should be an object (0.754083ms)
10  ✔ should have a helloWorld property (0.518958ms)
11✔ NPM Package (1.754875ms)
12▶ Hello World Function
13  ✔ should be a function (0.136667ms)
14  ✔ should return the hello world message (0.063791ms)
15✔ Hello World Function (0.270417ms)
16▶ Goodbye Function
17  ✔ should be a function (0.13275ms)
18  ✔ should return the goodbye message (0.159541ms)
19✔ Goodbye Function (0.552542ms)
20ℹ tests 6
21ℹ suites 3
22ℹ pass 6
23ℹ fail 0
24ℹ cancelled 0
25ℹ skipped 0
26ℹ todo 0
27ℹ duration_ms 113.692542

Testes em um pipeline

Agora que você tem testes para validar o comportamento do código, pode usá-los em um pipeline. Isso ajuda a garantir que nenhuma alteração no repositório afete o funcionamento do código. Siga as etapas abaixo para criar um fluxo de trabalho de testes como parte do pipeline do projeto.

1. Crie uma GitHub Action para seu repositório: https://github.com/<your-account-or-organization>/<your-repo-name>/actions/new

2. Renomeie o fluxo de trabalho para tests.yml

3. Insira o seguinte script da Snyk GitHub Action no arquivo do fluxo de trabalho:

1name: Tests
2
3on:
4  push:
5    branches: [ main ]
6  pull_request:
7    branches: [ main ]
8
9jobs:
10  build:
11
12    runs-on: ubuntu-latest
13
14    strategy:
15      matrix:
16        node-version: [22.x]
17
18    steps:
19      - uses: actions/checkout@v4
20      - name: Use Node.js ${{ matrix.node-version }}
21        uses: actions/setup-node@v4
22        with:
23          node-version: ${{ matrix.node-version }}
24      - run: npm ci
25      - run: npm test

Este script YAML faz checkout do código mais recente, instala as dependências e executa o comando npm test para rodar os testes. Isso é feito para cada versão do Node.js listada no campo node-version, para que você possa garantir que o código funcione como esperado em cada runtime.

Agora, você terminou de configurar o projeto para executar e avaliar testes no código do pacote npm. Mas talvez esteja se perguntando: “como testar usando meu pacote npm em outro projeto?” Vamos ver como fazer isso.

Testes do pacote

Uma coisa é confiar no código do seu pacote npm com testes de unidade; outra é garantir uma boa experiência de uso do pacote como um todo. Para isso, você precisa adicionar o pacote npm como dependência em outro projeto e verificar se ele funciona como esperado nesse contexto. Veja cinco maneiras de fazer isso:

1. Instalar usando a saída de npm pack

2. Instalar usando um caminho relativo

3. Instalar usando npm link

4. Instale por meio de um registro (como o registro público do npm em npmjs.com)

5. Use Verdaccio (um projeto de registro privado de npm de código aberto) para executar as etapas de publicação e instalação de pacotes de ponta a ponta como parte do seu CI

npm pack

Essa abordagem usa o comando npm pack para empacotar e compactar seu pacote npm em um único arquivo (<package-name>.tgz). Em seguida, você pode acessar o projeto em que quer usar o pacote e instalá-lo por meio desse arquivo. Veja as etapas:

1. No diretório do seu pacote npm, execute npm pack no terminal. Anote o arquivo .tgz gerado e onde ele está localizado.

2. Acesse o diretório do projeto em que você quer usar o pacote npm. Exemplo: cd /path/to/project

3. No diretório do projeto client, execute npm install /path/to/package.tgz, substituindo pelo caminho correto do arquivo .tgz gerado na etapa 1

4. Agora você pode começar a usar o pacote nesse projeto client para testar

Essa opção oferece uma experiência de uso do seu pacote npm mais próxima da produção.

npm link

Essa abordagem usa o comando npm link para apontar para o diretório do pacote ao tentar instalá-lo em projetos client. Veja as etapas:

1. No diretório do seu pacote npm, execute npm link no terminal

2. Acesse o diretório do projeto em que você quer usar o pacote npm. Exemplo: cd /path/to/project

3. No diretório do projeto client, execute npm link <name-of-your-package>

Isso fará com que seu projeto client aponte para o diretório do pacote npm ao referenciá-lo no código. Essa opção não oferece uma experiência de uso do pacote totalmente semelhante à de produção, mas permite verificar se tudo funciona como esperado.

Caminho relativo

Essa abordagem aproveita o conhecimento que você já tem sobre o comando npm install. É semelhante a npm link, mas sem precisar aprender um novo comando, como link.

1. No diretório do projeto client, execute npm install /path/to/your/package no terminal.

Assim como a abordagem com npm link, essa opção permite testar rapidamente a funcionalidade do pacote em um projeto cliente, mas não oferece uma experiência totalmente semelhante à de produção. Isso acontece porque ela aponta para o diretório completo do código-fonte do pacote, e não para uma versão compilada como a que você encontraria em um registro npm.

Registro npm

Essa abordagem usa o registro público (ou o seu próprio) de pacotes npm. Ela envolve publicar seu pacote e instalá-lo como você faria com qualquer outro pacote npm.

1. Publique seu pacote npm seguindo as etapas descritas anteriormente neste artigo, usando o comando npm publish

2. Acesse o diretório do projeto em que você quer usar o pacote npm. Exemplo: cd /path/to/project

3. No diretório do projeto client, execute npm install <name-of-your-package>

Agradecemos a Mirco Kraenz (@MKraenz), que criou uma thread no Twitter resumindo o que aprendemos sobre isso durante uma transmissão ao vivo!

Agora você já criou seu pacote para oferecer suporte a formatos de módulo modernos e verificou se ele funciona como esperado por meio de testes unitários e de empacotamento. Em seguida, você precisa garantir que não haja problemas de segurança e impedir que novos problemas sejam introduzidos no seu pacote npm.

Implementação de verificações de segurança

Assim como você não quer vulnerabilidades de segurança nos seus próprios projetos, também não quer introduzi-las nos projetos de outras pessoas. Criar um pacote npm que será usado em muitos outros projetos traz uma responsabilidade ainda maior de garantir a segurança. Você precisa implementar verificações de segurança para monitorar vulnerabilidades, emitir alertas e ajudar a mitigá-las. Uma ferramenta como o Snyk pode simplificar o trabalho necessário para isso.

Neste exemplo de pacote npm, você usa o GitHub para gerenciar o código-fonte. Por isso, vai aproveitar o recurso GitHub Actions para integrar o Snyk ao seu fluxo de trabalho. O Snyk tem um projeto de referência de GitHub Actions que ajuda a começar e oferece exemplos para outras linguagens de programação e ferramentas que você talvez use nos seus projetos.

1. O Snyk é gratuito. Cadastre-se e obtenha seu token de API do Snyk.

2. Adicione seu token de API do Snyk como um segredo do repositório no GitHub: https://github.com/<your-account-or-organization>/<your-repo-name>/settings/secrets/actions/new

3. Crie uma nova GitHub Action para seu repositório: https://github.com/<your-account-or-organization>/<your-repo-name>/actions/new

4. Renomeie o fluxo de trabalho para snyk.yml.

5. Insira o seguinte script do Snyk no arquivo do fluxo de trabalho:

1name: Snyk Security Check
2on: [push,pull_request]
3jobs:
4  security:
5    runs-on: ubuntu-latest
6    steps:
7      - uses: actions/checkout@main
8      - name: Run Snyk to check for vulnerabilities
9        uses: snyk/actions/node@master
10        env:
11          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}

6. Faça commit das suas alterações.

7. Verifique se a Action foi executada com sucesso: https://github.com/<your-account-or-organization>/<your-repo-name>/actions

Com isso configurado, sempre que alguém fizer push para seu repositório ou abrir uma pull request nele, uma verificação de segurança será executada para garantir que nenhuma vulnerabilidade seja introduzida no pacote. Se encontrar algum problema, a Action falhará e alertará você com os detalhes. Em seguida, você vai automatizar o controle de versões e a publicação do seu pacote npm.

Quer saber sobre problemas de segurança antes de as alterações serem enviadas para seu repositório? Instale o plugin do Snyk para a ferramenta de desenvolvimento que você preferir. Prefere usar ferramentas de CLI? Adicione também a CLI do Snyk ao seu conjunto de ferramentas. Elas ajudam a detectar problemas de segurança durante o desenvolvimento e a alertar você mais cedo no fluxo de trabalho do projeto.

Vale observar que essa configuração usa apenas o produto Snyk Open Source (SCA), e não o Snyk Code (SAST). O Snyk Code é nosso produto de segurança de código. Para aproveitar todos os recursos, primeiro você precisa ativá-lo gratuitamente na sua conta Snyk e, em seguida, adicioná-lo ao script do fluxo de trabalho. Para saber mais sobre como usar o Snyk Code no seu pipeline, leia este artigo: Como criar um pipeline seguro com GitHub Actions (o exemplo usa Java e Maven, mas você pode adaptá-lo para Node.js e npm).

Automatização do gerenciamento de versões e da publicação

Sempre que você mescla alterações na sua branch principal, não quer atualizar manualmente a versão do pacote npm e publicá-lo. Em vez disso, você pode automatizar esse processo. Se você se lembra do exemplo simples de pacote npm apresentado anteriormente neste artigo, usou o seguinte comando para publicar seu pacote:

1npm publish

Também é importante seguir o padrão do setor para versionamento semântico, para que quem usa seu pacote entenda o impacto das diferentes alterações de versão que você publica no registro.

O que é versionamento semântico?

O versionamento semântico define que a versão tenha três números: o primeiro representa a versão principal (major), o segundo, a versão secundária (minor) e o último, a correção (patch). Para saber mais sobre versionamento semântico, gerenciamento de versões e arquivos de bloqueio, leia O que é o package-lock.json e como funciona um arquivo de bloqueio com pacotes Yarn e NPM

E se você pudesse deixar de fazer tudo isso manualmente e, em vez disso, configurar um fluxo de trabalho automatizado com GitHub Actions para publicar pacotes npm? Você pode: existe uma ferramenta chamada Semantic Release, que se integra ao GitHub Actions. Para automatizar esse processo, você usa os chamados commits convencionais ao confirmar alterações no projeto. Assim, a automação atualiza tudo adequadamente e prepara a próxima versão do projeto para você.

As etapas a seguir mostram como configurar isso para seu pacote npm moderno.

1. No terminal, execute: npm i -D semantic-release

2. No terminal, execute: npx semantic-release-cli setup

3. Siga as instruções do terminal e forneça os tokens necessários:

• Você precisará de um token de acesso pessoal do GitHub. Para criar um, acesse https://github.com/settings/tokens/new?scopes=public_repo

• Ao criar esse token, use os seguintes escopos:

• Clique no botão “Generate token” e copie e salve o valor exibido na página.

• Você também precisará de um token de acesso do npm do tipo Automation, para uso exclusivo em ambientes de CI, a fim de contornar a autenticação de dois fatores da sua conta. Para criar um, acesse https://www.npmjs.com/settings/<your-npm-account>/tokens. Selecione o tipo “Automation”, pois ele será usado em um fluxo de trabalho de CI/CD.

1bc@mbp-snyk modern-npm-package % npx semantic-release-cli setup
2? What is your npm registry? https://registry.npmjs.org/
3? What is vour nom username? clarkio
4? What is your pm password? [hidden]
5? What is your NPM two-factor authentication code? <2FA code>
6Provide a GitHub Personal Access Token (create a token at https://github.com/settings/tokens/new?scopes=repo
7<token>
8? What CI are you using? Github Actions
9bc@mbp-snyk modern-npm-package %

4. Adicione seu token do npm ao repositório do GitHub como um segredo do repositório: https://github.com/<your-name-or-organization>/<your-repository>/settings/secrets/actions/new. Defina o nome do segredo como NPM_TOKEN e use o valor obtido na etapa anterior

5. No projeto, abra o arquivo package.json e adicione uma chave releases como mostrado abaixo. Se a branch principal do seu repositório ainda se chamar master, e não main, atualize o valor de branches acima de acordo.

1"release": {
2    "branches": ["main"]
3  }

6. Adicione também uma chave publishConfig ao arquivo package.json:

1"publishConfig": {
2    "access": "public"
3 }

7. Teste tudo executando uma simulação com o script npm semantic-release. Use o comando a seguir e defina os valores de NPM_TOKEN= e GH_TOKEN= com os tokens correspondentes. Depois, copie e execute o comando completo no terminal para verificar se tudo funciona corretamente. O processo ficará registrado na saída do terminal. Se houver algum problema, ele aparecerá ali com detalhes para ajudar você a resolvê-lo.

8. Depois de confirmar que a simulação foi concluída com sucesso, configure uma nova GitHub Action no repositório para automatizar a publicação. Acesse seu repositório no GitHub e clique em “Actions”.

9. Clique na opção New workflow.

10. Renomeie o fluxo de trabalho para release.yml.

11. Adicione o script YAML abaixo ao novo arquivo do fluxo de trabalho. Basicamente, esse script determina que o job de lançamento seja executado assim que a verificação de segurança do Snyk for concluída com sucesso. O job de lançamento faz checkout do código, configura um ambiente Node.js, instala as dependências e executa o Semantic Release usando seus tokens do GitHub e do npm.

1name: Release
2on:
3  workflow_run:
4    workflows: ['Snyk Security Check', 'Tests']
5    branches: [main]
6    types:
7      - completed
8
9permissions:
10  contents: read
11
12jobs:
13  release:
14    name: Release
15    runs-on: ubuntu-latest
16    permissions:
17      contents: write # to be able to publish a GitHub release
18      issues: write # to be able to comment on released issues
19      pull-requests: write # to be able to comment on released pull requests
20      id-token: write
21    steps:
22      - name: Checkout
23        uses: actions/checkout@v4
24        with:
25          fetch-depth: 0
26      - name: Setup Node.js
27        uses: actions/setup-node@v4
28        with:
29          node-version: 'lts/*'
30      - name: Install dependencies
31        run: npm ci
32      - name: Verify the integrity of provenance attestations and registry signatures for installed dependencies
33        run: npm audit signatures
34      - name: Release
35        env:
36          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
37          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
38        run: npx semantic-release

Basicamente, esse script determina que o job de lançamento seja executado assim que a verificação de segurança e os testes do Snyk forem concluídos com sucesso. O job de lançamento faz checkout do código, configura um ambiente Node.js, instala as dependências e executa o Semantic Release usando seus tokens do GitHub e do npm.

• Observação: o GitHub Actions inclui um segredo/variável de ambiente GITHUB_TOKEN integrado, então não é necessário fornecer o token de acesso pessoal neste ambiente. O PAT serve apenas para testar localmente sua configuração do semantic-release.

12. Faça commit das alterações locais e envie-as para seu repositório do GitHub

• Para isso, execute o comando git commit -am '<your commit message>' no terminal e, em seguida, git push.

• Você também pode fazer isso no VS Code usando o recurso de controle de versão.

13. Com tudo configurado, você pode usar commits convencionais para enviar alterações à sua branch principal (ou mesclar pull requests). O fluxo de trabalho de lançamento será executado — depois da verificação de segurança do Snyk, é claro. Veja um exemplo disso no fluxo de trabalho do repositório modern-npm-package.

Monitoramento contínuo de segurança com o Snyk pelo GitHub

É útil fazer verificações de segurança diretamente no processo de commit do código, mas ainda podem passar despercebidas vulnerabilidades que surgem entre os commits. Por exemplo, se você não envia código para o repositório há alguns meses, pode não ficar sabendo das novas vulnerabilidades descobertas nesse período. É aí que a Snyk ajuda ainda mais! Ao conectar seu repositório do GitHub à Snyk, ela monitora automaticamente novas vulnerabilidades e alerta você, independentemente da frequência com que você trabalha no projeto. Além disso, ela cria pull requests automaticamente para ajudar você a corrigir os problemas de segurança.

Dois produtos da Snyk são especialmente úteis para garantir a segurança do código dos seus pacotes npm e das dependências. O Snyk Code ajuda a proteger o código dos seus pacotes, enquanto o Snyk Open Source monitora suas dependências de código aberto em busca de vulnerabilidades.

Para começar a aproveitar ao máximo sua conta gratuita da Snyk, siga as etapas abaixo:

1. Acesse sua conta gratuita da Snyk

2. Selecione Add project e, em seguida, GitHub.

3. Pesquise o repositório do seu projeto pelo nome e marque a caixa ao lado dele.

4. Confirme se o repositório foi importado com sucesso para a Snyk.

Comece a criar pacotes npm modernos

Vamos recapitular o que você aprendeu neste artigo. Primeiro, você conheceu as etapas para configurar, criar e publicar um pacote npm simples. Foi uma ótima forma de entender o que é necessário para publicar seu primeiro pacote npm. No entanto, esse processo é bastante manual e não é sustentável se você pretende criar um pacote npm para uso em produção.

Para criar um pacote pronto para produção, você também aprendeu a gerar versões nos formatos de módulo CommonJS (CJS) e ECMAScript (ESM), configurar e escrever testes unitários, implementar verificações de segurança e automatizar o gerenciamento de versões e a publicação. Com esse conhecimento, você está pronto para criar muitos outros pacotes npm próprios, fáceis de usar pela comunidade ou pela sua empresa.

Use o verificador gratuito de código JavaScript da Snyk para encontrar e corrigir vulnerabilidades no seu código.