Por que reescrevi o type-tune de TypeScript para Rust? 🦀
Hoi hoi! 👋
Sou @nyaomaru, um engenheiro frontend que adora TypeScript e camarões, não caranguejos! 🦐
E mesmo assim, de algum jeito, acabei criando uma ferramenta em Rust. 🙀🦀
Recentemente, lancei uma nova ferramenta CLI open source chamada type-tune.
https://github.com/necoz-oss/type-tune
type-tune encontra tipos TypeScript compartilhados e ajuda a movê-los para um lugar mais adequado, sem precisar atualizar manualmente imports, dependências e barrel exports.
Mas por que uma ferramenta para TypeScript, criada por alguém que adora TypeScript, foi escrita em Rust? 🤔
🐈 Tudo começou com TypeScript
Naturalmente, a implementação original do type-tune foi escrita em TypeScript.
Ela já estava pronta em setembro, com quase 20 mil linhas de TypeScript, incluindo testes, comentários e linhas em branco.
Por volta dessa época, acabei assistindo a este vídeo do DHH.
https://www.youtube.com/watch?v=vDjW_dRyKXY
Não concordei com tudo, mas gostei especialmente da ideia de aproveitar esta época para fazer coisas que realmente nos empolgam.
Claro que, fora dos projetos pessoais, não acho que possamos simplesmente entregar tudo à IA. Alguém ainda precisa entender e manter o software.
Mas, enquanto assistia ao vídeo, tive uma ideia simples.
Se dá para ir de Rails para Rust, por que não de TypeScript para Rust? 🦀
🦀 De TypeScript para Rust
Eu já tinha uma implementação funcional, documentos de design, testes e tipos TypeScript bem definidos.
Por exemplo, traduzir um modelo de dados como este:
type CandidateKind = "typeAlias" | "interface";
type Candidate = {
id: string;
name: string;
kind: CandidateKind;
referrers: string[];
};
Para algo assim:
enum CandidateKind {
TypeAlias,
Interface,
}
struct Candidate {
id: String,
name: String,
kind: CandidateKind,
referrers: Vec<String>,
}
Claro que migrar a aplicação inteira envolveu muito mais do que traduzir definições de tipos.
Mas ter um design e uma implementação existentes facilitou bastante o trabalho.
Com a ajuda da IA, concluí a migração em menos de um mês, trabalhando nela como projeto paralelo.
Os resultados foram satisfatórios. 😻
- Melhor desempenho de execução.
- Distribuição de binários nativos.
- Usuários do npm não precisam de um ambiente de desenvolvimento Rust.
Ainda é possível instalar o type-tune como qualquer outra ferramenta de desenvolvimento TypeScript.
pnpm add -D type-tune
O launcher do npm exige Node.js 22+, mas a implementação principal roda como um binário nativo.
Até aqui, tudo ótimo!
Exceto por um pequeno problema. 😿
🙀 O type-tune ficou mais rápido. Seu desenvolvedor ficou mais lento.
Eu mal conhecia Rust. 😹
Tenho facilidade para revisar código TypeScript gerado por IA, mas em Rust ainda estou aprendendo os fundamentos.
Considere, por exemplo, ownership e borrowing.
Em TypeScript, isto funciona perfeitamente:
function printName(name: string) {
console.log(name);
}
const name = "OrderSummary";
printName(name);
console.log(name); // OK
Porém, uma implementação semelhante em Rust não compila.
fn print_name(name: String) {
println!("{}", name);
}
fn main() {
let name = String::from("OrderSummary");
print_name(name);
println!("{}", name); // Error: value borrowed after move
}
A ownership de name é transferida para print_name.
Uma maneira de resolver isso é emprestar o valor, usando borrowing.
fn print_name(name: &str) {
println!("{}", name);
}
fn main() {
let name = String::from("OrderSummary");
print_name(&name);
println!("{}", name); // OK
}
Outra opção é clonar o valor.
print_name(name.clone());
println!("{}", name); // OK
As duas soluções compilam, mas clones desnecessários podem introduzir alocações adicionais.
Então, quando a IA gera um .clone(), preciso entender se ele é realmente necessário ou se borrowing seria mais adequado.
O mesmo vale para os limites de visibilidade.
Por exemplo, tornar um helper interno público pode resolver um problema de acesso:
pub fn resolve_destination() {
// ...
}
Mas, se a função só é usada dentro do mesmo crate, talvez não seja necessário expô-la publicamente.
pub(crate) fn resolve_destination() {
// ...
}
E se ela só é usada dentro do próprio módulo, pode continuar privada.
fn resolve_destination() {
// ...
}
O compilador aceita as três declarações, mas cada uma representa uma decisão arquitetural diferente.
Também ainda estou aprendendo quando macros são apropriadas e quando funções comuns são suficientes.
A IA consegue gerar código que compila, mas eu ainda preciso entender se as decisões de design são adequadas.
Em TypeScript, consigo tomar essas decisões relativamente rápido. Em Rust, muitas vezes preciso parar e aprender algo antes de continuar a revisão.
A IA consegue gerar código Rust muito mais rápido do que eu consigo entendê-lo.
Eu queria acelerar o desenvolvimento do meu projeto paralelo, mas introduzi um novo gargalo.
Eu mesmo.
Que bela otimização! 😹
🎨 Criar sem aprender
Claro que eu poderia simplesmente fazer vibe coding.
Poderia continuar apertando Enter sempre que a IA pedisse aprovação e provavelmente lançar funcionalidades mais rápido.
Mas, para mim, criar algo sem aprender nada é só mais uma tarefa.
E acredito que, se continuar fazendo apenas essas tarefas, vou perder aos poucos minha capacidade de criar.
Gosto de usar IA para aprender conceitos desconhecidos e explorar novas abordagens.
Mas não quero passar meu tempo simplesmente produzindo coisas sem entendê-las.
Não quero me tornar uma tecla Enter muito cara. 😹
Me arrependo de ter escolhido Rust?
De jeito nenhum!
Foi uma experiência valiosa, e sou grato por vivermos numa época em que podemos nos desafiar assim com tanta facilidade.
Agora, vamos falar sobre o que realmente construí!
🛠️ O design por trás do type-tune
Uma decisão arquitetural permaneceu intacta durante toda a migração.
Scan / Plan / Apply
Imagine um projeto TypeScript típico.
src/
├── features/
│ ├── orders/
│ │ └── order-page.ts
│ ├── dashboard/
│ │ └── dashboard.ts
│ └── reports/
│ └── reports.ts
Inicialmente, um tipo pertence à feature de pedidos.
// features/orders/order-page.ts
export type OrderSummary = {
id: string;
total: number;
};
Mas, à medida que a aplicação cresce, outras features começam a importá-lo.
// features/dashboard/dashboard.ts
import type { OrderSummary } from "../orders/order-page";
export function calculateRevenue(orders: OrderSummary[]) {
return orders.reduce((sum, order) => sum + order.total, 0);
}
// features/reports/reports.ts
import type { OrderSummary } from "../orders/order-page";
export function createReport(order: OrderSummary) {
return `${order.id}: ${order.total}`;
}
O tipo continua útil, mas sua localização original talvez já não seja adequada.
Ferramentas como Knip ajudam a remover código não utilizado.
type-tune resolve outro problema: reorganizar tipos que ainda estão em uso.
🔍 1. Scan
pnpm exec type-tune scan --project tsconfig.json
type-tune analisa type aliases exportados, interfaces, referências e dependências relevantes para identificar possíveis candidatos à extração.
Nenhum código-fonte é modificado.
📋 2. Plan
Encontrar um tipo que pode ser movido não significa necessariamente que ele deve ser movido.
Por isso, type-tune gera um plano que pode ser revisado.
pnpm exec type-tune plan \
--project tsconfig.json \
--out .type-tune/plan.json \
--markdown .type-tune/plan.md
Ele gera dois arquivos:
plan.json— Metadados dos candidatos e informações de validação.plan.md— Um plano legível e editável por pessoas.
Todos os candidatos são ignorados por padrão.
Aqui vai um exemplo simplificado de plan.md:
- [ignore] <candidate-id> `OrderSummary`
- kind: `typeAlias`
- from: `src/features/orders/order-page.ts`
- to: `src/features/orders/types/order.ts`
Você pode aprovar o candidato e personalizar seu destino.
- [ignore] <candidate-id> OrderSummary
+ [apply] <candidate-id> OrderSummary
- kind: typeAlias
- from: src/features/orders/order-page.ts
- - to: src/features/orders/types/order.ts
+ - to: src/domains/orders/types/order-summary.ts
Talvez ele pertença a um diretório compartilhado, a um módulo específico de domínio ou exatamente ao lugar onde já está.
Essa é uma decisão arquitetural.
Você decide o que será movido e para onde.
🚚 3. Apply
Visualize previamente as alterações selecionadas:
pnpm exec type-tune apply \
--plan .type-tune/plan.json \
--markdown .type-tune/plan.md \
--dry-run
Depois, aplique-as:
pnpm exec type-tune apply \
--plan .type-tune/plan.json \
--markdown .type-tune/plan.md
A estrutura resultante do projeto:
src/
├── domains/
│ └── orders/
│ └── types/
│ └── order-summary.ts ← Moved!
└── features/
├── orders/
│ └── order-page.ts
├── dashboard/
│ └── dashboard.ts
└── reports/
└── reports.ts
O tipo agora está em sua nova casa.
// domains/orders/types/order-summary.ts
export type OrderSummary = {
id: string;
total: number;
};
Os imports suportados são atualizados automaticamente.
- import type { OrderSummary } from "../orders/order-page";
+ import type { OrderSummary } from "../../domains/orders/types/order-summary";
E o módulo original mantém um re-export para compatibilidade.
// features/orders/order-page.ts
export type { OrderSummary } from "../../domains/orders/types/order-summary";
type-tune também valida a reescrita usando o compilador TypeScript e reverte as alterações se a validação normal falhar.
Ainda assim, você deve revisar o diff resultante e executar os testes e builds específicos do projeto.
🧩 Automatize o trabalho, não as decisões
Por que separar Scan, Plan e Apply?
Porque descobrir oportunidades, tomar decisões arquiteturais e executar alterações são responsabilidades diferentes.
type-tune também oferece revisão opcional assistida por IA:
pnpm exec type-tune plan \
--project tsconfig.json \
--ai-review \
--ai-dry-run
A IA pode fornecer observações adicionais de revisão, mas não controla a reescrita do código-fonte. O comando acima permite visualizar a solicitação de revisão por IA sem contatar um provedor.
Curiosamente, é assim também que quero trabalhar com IA no meu próprio desenvolvimento.
Automatizar o trabalho tedioso sem tirar dos desenvolvedores as decisões arquiteturais.
Essa é a filosofia por trás do type-tune.
💚 Dê aos seus tipos TypeScript uma casa melhor!
Você pode começar simplesmente escaneando seu projeto.
npx type-tune scan --project tsconfig.json
Não precisa mover nada ainda. Só veja o que encontra! 😸
https://github.com/necoz-oss/type-tune
https://type-tune-docs.vercel.app/
Feedback, ideias, issues e contribuições são sempre bem-vindos!
E se você desenvolve em Rust, por favor, ensine este pobre gato TypeScript a se tornar um caranguejo competente. 😹🦀
Small. Simple. Useful. Built Together!
Obrigado por ler! 🙌💚