0

Vì sao mình viết lại type-tune từ TypeScript sang Rust? 🦀

Hoi hoi! 👋

Mình là @nyaomaru, một frontend engineer yêu TypeScript và tôm, chứ không phải cua! 🦐

Ấy vậy mà chẳng hiểu sao cuối cùng mình lại xây dựng một công cụ bằng Rust. 🙀🦀

Gần đây, mình đã phát hành một công cụ CLI mã nguồn mở mới có tên là type-tune.

https://github.com/necoz-oss/type-tune

type-tune tìm các type TypeScript được dùng chung và giúp chuyển chúng đến vị trí phù hợp hơn mà không cần cập nhật thủ công các import, dependency và barrel export.

Nhưng tại sao một công cụ dành cho TypeScript, do một người yêu TypeScript tạo ra, lại được viết bằng Rust? 🤔


🐈 Mọi thứ bắt đầu với TypeScript

Tất nhiên, phiên bản ban đầu của type-tune được viết bằng TypeScript.

Nó đã hoàn thành từ tháng 9, với gần 20.000 dòng TypeScript, tính cả test, comment và dòng trống.

Khoảng thời gian đó, mình tình cờ xem được video này của DHH.

https://www.youtube.com/watch?v=vDjW_dRyKXY

Mình không đồng ý với tất cả những gì được nói trong video, nhưng đặc biệt thích ý tưởng tận dụng thời đại này để theo đuổi những điều thực sự khiến chúng ta hào hứng.

Tất nhiên, ngoài phạm vi các dự án cá nhân, mình không nghĩ chúng ta có thể đơn giản giao mọi thứ cho AI. Vẫn phải có người hiểu và bảo trì phần mềm.

Nhưng trong lúc xem video, một suy nghĩ đơn giản chợt xuất hiện.

Nếu có thể chuyển từ Rails sang Rust, tại sao lại không thể chuyển từ TypeScript sang Rust? 🦀


🦀 Từ TypeScript sang Rust

Mình đã có sẵn một phiên bản hoạt động được, tài liệu thiết kế, test và các type TypeScript được định nghĩa rõ ràng.

Ví dụ, chuyển một data model như thế này:

type CandidateKind = "typeAlias" | "interface";

type Candidate = {
  id: string;
  name: string;
  kind: CandidateKind;
  referrers: string[];
};

Thành một cấu trúc như thế này:

enum CandidateKind {
    TypeAlias,
    Interface,
}

struct Candidate {
    id: String,
    name: String,
    kind: CandidateKind,
    referrers: Vec<String>,
}

Tất nhiên, việc chuyển đổi toàn bộ ứng dụng phức tạp hơn nhiều so với việc chuyển các định nghĩa type.

Nhưng có sẵn thiết kế và implementation đã giúp công việc dễ dàng hơn rất nhiều.

Với sự hỗ trợ của AI, mình hoàn tất quá trình migration trong chưa đầy một tháng, trong thời gian làm side project.

Kết quả khá hài lòng. 😻

  • Hiệu năng thực thi tốt hơn.
  • Phân phối dưới dạng native binary.
  • Người dùng npm không cần môi trường phát triển Rust.

Bạn vẫn có thể cài type-tune giống như những công cụ phát triển TypeScript quen thuộc khác.

pnpm add -D type-tune

Launcher của npm yêu cầu Node.js 22 trở lên, nhưng phần implementation cốt lõi chạy dưới dạng native binary.

Đến đây thì mọi thứ đều ổn!

Ngoại trừ một vấn đề nho nhỏ. 😿


🙀 type-tune nhanh hơn. Developer của nó lại chậm hơn.

Mình gần như chẳng biết gì về Rust. 😹

Mình khá tự tin khi review code TypeScript do AI tạo ra, nhưng với Rust, mình vẫn đang học những kiến thức cơ bản.

Ví dụ, hãy xem ownership (quyền sở hữu) và borrowing (mượn giá trị).

Trong TypeScript, đoạn code này hoàn toàn ổn:

function printName(name: string) {
  console.log(name);
}

const name = "OrderSummary";

printName(name);
console.log(name); // OK

Tuy nhiên, implementation tương tự trong Rust lại không compile được.

fn print_name(name: String) {
    println!("{}", name);
}

fn main() {
    let name = String::from("OrderSummary");

    print_name(name);
    println!("{}", name); // Error: value borrowed after move
}

Ownership của name đã được chuyển sang print_name.

Một cách sửa là mượn giá trị thay vì chuyển ownership.

fn print_name(name: &str) {
    println!("{}", name);
}

fn main() {
    let name = String::from("OrderSummary");

    print_name(&name);
    println!("{}", name); // OK
}

Một lựa chọn khác là clone giá trị.

print_name(name.clone());
println!("{}", name); // OK

Cả hai cách đều compile được, nhưng clone không cần thiết có thể dẫn đến việc cấp phát thêm bộ nhớ.

Vì vậy, khi AI tạo ra một .clone(), mình cần hiểu nó có thực sự cần thiết hay borrowing sẽ phù hợp hơn.

Điều tương tự cũng áp dụng với phạm vi visibility.

Ví dụ, biến một helper nội bộ thành public có thể giải quyết vấn đề truy cập:

pub fn resolve_destination() {
    // ...
}

Nhưng nếu function chỉ được sử dụng trong cùng một crate, việc công khai nó ra bên ngoài có thể không cần thiết.

pub(crate) fn resolve_destination() {
    // ...
}

Và nếu nó chỉ được sử dụng trong module của chính nó, ta có thể giữ nó ở chế độ private.

fn resolve_destination() {
    // ...
}

Compiler chấp nhận cả ba khai báo, nhưng mỗi cách thể hiện một quyết định kiến trúc khác nhau.

Mình cũng vẫn đang học khi nào nên dùng macro và khi nào function thông thường là đủ.

AI có thể tạo ra code compile được, nhưng mình vẫn cần hiểu liệu những quyết định thiết kế của nó có phù hợp hay không.

Với TypeScript, mình có thể đưa ra những quyết định này khá nhanh. Với Rust, mình thường phải dừng lại học thêm một điều gì đó trước khi tiếp tục review.

AI có thể tạo code Rust nhanh hơn rất nhiều so với tốc độ mình hiểu được nó.

Mình muốn tăng tốc phát triển side project, nhưng lại tạo thêm một bottleneck mới.

Chính mình.

Một pha tối ưu tuyệt vời làm sao! 😹


🎨 Sáng tạo mà không học hỏi

Tất nhiên, mình có thể cứ vibe coding thôi.

Mỗi lần AI yêu cầu phê duyệt, mình chỉ việc nhấn Enter, và có lẽ sẽ phát hành tính năng nhanh hơn.

Nhưng với mình, tạo ra thứ gì đó mà không học được gì chỉ là thêm một công việc phải hoàn thành.

Và mình tin rằng nếu cứ làm những công việc như vậy, khả năng sáng tạo của mình sẽ dần mất đi.

Mình thích sử dụng AI để học các khái niệm chưa quen thuộc và khám phá những cách tiếp cận mới.

Nhưng mình không muốn dành thời gian chỉ để tạo ra những thứ mà bản thân không hiểu.

Mình không muốn trở thành một phím Enter cực kỳ đắt tiền. 😹

Vậy mình có hối hận vì đã chọn Rust không?

Hoàn toàn không!

Đó là một trải nghiệm quý giá, và mình biết ơn vì chúng ta đang sống trong thời đại mà việc thử thách bản thân như thế này trở nên dễ dàng đến vậy.

Giờ thì hãy nói về thứ mình thực sự đã xây dựng nhé!


🛠️ Thiết kế đằng sau type-tune

Có một quyết định kiến trúc vẫn được giữ nguyên trong suốt quá trình migration.

Scan / Plan / Apply

Hãy xem một project TypeScript điển hình.

src/
├── features/
│   ├── orders/
│   │   └── order-page.ts
│   ├── dashboard/
│   │   └── dashboard.ts
│   └── reports/
│       └── reports.ts

Ban đầu, một type thuộc về feature orders.

// features/orders/order-page.ts

export type OrderSummary = {
  id: string;
  total: number;
};

Nhưng khi ứng dụng phát triển, các feature khác bắt đầu import type đó.

// 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}`;
}

Type này vẫn hữu ích, nhưng vị trí ban đầu của nó có thể không còn phù hợp nữa.

Những công cụ như Knip giúp chúng ta loại bỏ code không sử dụng.

type-tune giải quyết một vấn đề khác: tổ chức lại những type vẫn đang được sử dụng.


🔍 1. Scan

pnpm exec type-tune scan --project tsconfig.json

type-tune phân tích các type alias và interface được export, các reference và dependency liên quan để xác định những ứng viên có thể được tách ra.

Không có source code nào bị thay đổi.


📋 2. Plan

Tìm thấy một type có thể di chuyển không nhất thiết có nghĩa là nên di chuyển nó.

Đó là lý do type-tune tạo ra một plan để chúng ta review.

pnpm exec type-tune plan \
  --project tsconfig.json \
  --out .type-tune/plan.json \
  --markdown .type-tune/plan.md

Nó tạo hai file:

  • plan.json — Metadata của các ứng viên và thông tin validation.
  • plan.md — Một plan dễ đọc và có thể chỉnh sửa.

Mặc định, mọi ứng viên đều ở trạng thái ignore.

Đây là một ví dụ đơn giản hóa của plan.md:

- [ignore] <candidate-id> `OrderSummary`
  - kind: `typeAlias`
  - from: `src/features/orders/order-page.ts`
  - to: `src/features/orders/types/order.ts`

Bạn có thể phê duyệt ứng viên và tùy chỉnh vị trí đích của nó.

- [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

Có thể nó nên nằm trong một thư mục dùng chung, một module dành riêng cho domain, hoặc ngay chính vị trí hiện tại.

Đó là một quyết định kiến trúc.

Bạn quyết định thứ gì sẽ được di chuyển và di chuyển đến đâu.


🚚 3. Apply

Xem trước các thay đổi đã chọn:

pnpm exec type-tune apply \
  --plan .type-tune/plan.json \
  --markdown .type-tune/plan.md \
  --dry-run

Sau đó áp dụng chúng:

pnpm exec type-tune apply \
  --plan .type-tune/plan.json \
  --markdown .type-tune/plan.md

Cấu trúc project sau khi thay đổi:

src/
├── domains/
│   └── orders/
│       └── types/
│           └── order-summary.ts  ← Moved!
└── features/
    ├── orders/
    │   └── order-page.ts
    ├── dashboard/
    │   └── dashboard.ts
    └── reports/
        └── reports.ts

Bây giờ type đã có một ngôi nhà mới.

// domains/orders/types/order-summary.ts

export type OrderSummary = {
  id: string;
  total: number;
};

Các import được hỗ trợ sẽ tự động cập nhật.

- import type { OrderSummary } from "../orders/order-page";
+ import type { OrderSummary } from "../../domains/orders/types/order-summary";

Và module ban đầu vẫn giữ một re-export để đảm bảo tương thích.

// features/orders/order-page.ts

export type { OrderSummary } from "../../domains/orders/types/order-summary";

type-tune cũng dùng TypeScript compiler để kiểm tra kết quả rewrite và rollback các thay đổi nếu quá trình validation thông thường thất bại.

Dù vậy, bạn vẫn nên review diff kết quả và chạy các test, build riêng của project.


🧩 Tự động hóa công việc, không phải quyết định

Tại sao lại tách riêng Scan, Plan và Apply?

Bởi vì phát hiện cơ hội cải thiện, đưa ra quyết định kiến trúc và thực thi thay đổi là những trách nhiệm khác nhau.

type-tune thậm chí còn hỗ trợ review bằng AI dưới dạng tùy chọn:

pnpm exec type-tune plan \
  --project tsconfig.json \
  --ai-review \
  --ai-dry-run

AI có thể cung cấp thêm ghi chú review, nhưng không kiểm soát việc rewrite source code. Command trên giúp xem trước yêu cầu AI review mà không liên hệ với AI provider.

Điều thú vị là đây cũng chính là cách mình muốn làm việc với AI trong quá trình phát triển của bản thân.

Tự động hóa những công việc nhàm chán mà không lấy đi quyền quyết định kiến trúc của developer.

Đó là triết lý đằng sau type-tune.


💚 Hãy tìm một ngôi nhà tốt hơn cho các type TypeScript của bạn!

Bạn có thể bắt đầu bằng việc đơn giản là scan project của mình.

npx type-tune scan --project tsconfig.json

Chưa cần di chuyển bất cứ thứ gì. Cứ xem bạn tìm được gì đã! 😸

https://github.com/necoz-oss/type-tune

https://type-tune-docs.vercel.app/

Feedback, ý tưởng, issue và các đóng góp luôn được chào đón!

Và nếu bạn là Rust developer, hãy dạy chú mèo TypeScript tội nghiệp này cách trở thành một chú cua thành thạo nhé. 😹🦀

Small. Simple. Useful. Built Together!

Cảm ơn bạn đã đọc! 🙌💚


All Rights Reserved

Viblo
Let's register a Viblo Account to get more interesting posts.