O Bun acabou de eliminar o Concurrently.

O Bun 1.4, uma reescrita significativa em Rust, chegou recentemente, introduzindo mais do que apenas melhorias de desempenho ao runtime de JavaScript. Esta atualização reforça a posição do Bun como um toolkit tudo-em-um, visando consolidar utilitários de desenvolvedor em uma plataforma única e coesa. Representa um movimento estratégico em direção a um ambiente de desenvolvimento mais integrado.

Central para o impacto do Bun 1.4 está seu novo executor de scripts integrado, que lida nativamente com a execução paralela e sequencial de scripts do package.json. Esta capacidade torna ferramentas de terceiros, como concurrently e npm-run-all, amplamente obsoletas para muitos projetos, absorvendo funcionalidades que anteriormente exigiam dependências externas. Os desenvolvedores agora podem usar a flag --parallel para executar múltiplos scripts simultaneamente.

O executor integrado oferece recursos essenciais, incluindo saída prefixada para clareza, correspondência de glob para seleção de scripts e filtragem de workspace. Uma opção também permite que outros scripts continuem mesmo se um deles apresentar erro, aumentando a robustez. Este mecanismo interno simplifica fluxos de trabalho de desenvolvimento complexos diretamente dentro do Bun.

Esta absorção de ferramentas comuns exemplifica a estratégia mais ampla do Bun para simplificar o ecossistema JavaScript. Ao fornecer alternativas nativas, o Bun reduz ativamente o inchaço do node_modules e simplifica a configuração do projeto, afastando-se de cadeias de ferramentas fragmentadas. Ele oferece uma experiência de desenvolvedor mais unificada e eficiente.

O Bun 1.4 introduz uma flag --parallel nativa, alterando fundamentalmente a forma como os desenvolvedores executam múltiplos scripts do package.json. Este aprimoramento elimina a necessidade de ferramentas externas como concurrently ou npm-run-all, simplificando fluxos de trabalho de desenvolvimento diretamente no Bun. Os usuários agora iniciam múltiplos servidores de desenvolvimento ou watchers simultaneamente a partir de um único comando.

Execute scripts simultaneamente listando-os após bun run --parallel. Por exemplo, bun run --parallel "dev:frontend" "dev:backend" inicia ambas as tarefas em paralelo. Isso espelha configurações comuns de package.json onde dev:frontend pode iniciar um servidor React e dev:backend uma API Node.js.

Melhorias na qualidade de vida acompanham a execução paralela. A saída de cada script simultâneo inclui automaticamente um nome prefixado, esclarecendo qual processo gerou qual log. Os desenvolvedores também podem aproveitar a correspondência de glob; bun run --parallel "dev:*" executará todos os scripts que correspondem ao prefixo dev:, como dev:frontend e dev:backend, sem listagem explícita.

Controle adicional está disponível através da opção --continue-on-error. Esta flag garante que uma falha de script não crítica, como um linter relatando erros, não interrompa todo o ambiente de desenvolvimento. Outros processos paralelos, como servidores de desenvolvimento ativos, continuam rodando ininterruptamente, preservando a continuidade do fluxo de trabalho. Este recurso aumenta a robustez em configurações complexas de desenvolvimento de múltiplos serviços.

O Bun 1.4 estende suas capacidades nativas de execução de scripts além do processamento paralelo com a introdução da flag --sequential. Este recurso complementar estabelece o Bun como um executor de tarefas completo e integrado, eliminando a necessidade de pacotes npm externos para gerenciar fluxos de trabalho de scripts complexos.

A flag --sequential garante que as tarefas sejam executadas em uma ordem definida, o que é crítico para inúmeros cenários de desenvolvimento e implantação onde existem dependências entre etapas. Casos de uso específicos incluem:

• Executar migrações de banco de dados até a conclusão antes que um servidor inicie.
• Executar um processo de build inteiramente antes de iniciar uma suíte de testes.
• Realizar operações sequenciais de preenchimento de dados (data seeding) onde a integridade dos dados depende de inserções ordenadas.

O Bun mantém uma experiência de desenvolvedor consistente tanto em operações paralelas quanto sequenciais. Os desenvolvedores aproveitam a mesma sintaxe elegante de scripts do package.json, beneficiando-se de uma saída clara e prefixada que atribui os logs diretamente ao script de origem, melhorando a depuração e o monitoramento.

Essa consistência se estende a recursos avançados de filtragem, permitindo um controle preciso sobre quais scripts são executados dentro de um workspace, o que é particularmente útil em ambientes de monorepo. Para informações abrangentes sobre essas opções de filtragem, consulte bun --filter | Bun Docs. A flag --sequential do Bun, juntamente com a --parallel, fornece uma orquestração de scripts nativa e robusta, simplificando a configuração do projeto e reduzindo significativamente a dependência de ferramentas como concurrently ou npm-run-all.

O Bun 1.4 introduz a flag --filter, um aprimoramento significativo para o gerenciamento de monorepo. Esse recurso permite que os desenvolvedores selecionem pacotes específicos dentro de um workspace ao executar scripts, simplificando diretamente fluxos de trabalho de projetos complexos. Ele aborda um desafio de longa data em ambientes de desenvolvimento de larga escala, indo além da execução genérica de scripts.

Anteriormente, coordenar comandos em diversos subpacotes frequentemente exigia scripts de shell personalizados ou configurações complexas de ferramentas com utilitários externos como Lerna ou Nx. Com o --filter, o Bun simplifica esse processo nativamente, incorporando a consciência de workspace em seu núcleo. Por exemplo, para executar testes apenas para um serviço de backend específico, os desenvolvedores executam bun run test --filter=@my-app/backend.

Este comando direciona especificamente o pacote @my-app/backend, isolando a execução dos testes sem iniciar operações em componentes não relacionados do projeto. A capacidade se estende além dos testes, aplicando-se a comandos de build, lint ou servidor de desenvolvimento em todo o workspace. Ele fornece um controle granular e eficiente sobre operações de múltiplos pacotes.

A flag --filter reduz drasticamente a dependência de soluções de script personalizadas, que se tornam difíceis de manter e depurar à medida que os projetos escalam. Essa integração nativa solidifica a utilidade do Bun para organizações que gerenciam bases de código extensas e dependências complexas. Isso posiciona o Bun 1.4 como um executor de tarefas robusto e tudo-em-um para workspaces de nível empresarial.

O que há de novo no Bun 1.4 para a execução de scripts?

O Bun 1.4 introduziu suporte nativo para executar scripts do package.json em paralelo (--parallel) ou sequencialmente (--sequential), eliminando a necessidade de pacotes de terceiros como concurrently ou npm-run-all.

Como o executor de scripts do Bun lida com erros?

Por padrão, se um script falha, todos os outros são encerrados. No entanto, você pode usar uma flag para permitir que os outros scripts continuem sendo executados mesmo se um encontrar um erro, o que é útil para ambientes de desenvolvimento complexos.

Posso executar scripts para pacotes específicos em um monorepo com o Bun?

Sim, o Bun inclui uma flag --filter que permite direcionar pacotes específicos dentro de um workspace (monorepo), permitindo a execução precisa de comandos em todo o seu projeto.

O Bun suporta apenas scripts paralelos?

Não, o Bun suporta a execução de scripts tanto em paralelo quanto sequencial. A flag --sequential executa scripts um após o outro, oferecendo a mesma saída prefixada e capacidades de filtragem que o executor paralelo.

Por que o Bun 1.4 é referido como uma reescrita em Rust?

A transcrição do vídeo menciona o Bun 1.4 como uma 'reescrita em Rust', indicando uma mudança arquitetural significativa onde partes importantes do runtime foram reescritas na linguagem de programação Rust para maior desempenho e segurança.