Template Literal Types pada TypeScript Memungkinkan Inferensi Protobuf Tanpa Codegen, Tapi Dengan Biaya Apa?

Komunitas pengembang sedang ramai membicarakan pustaka proof-of-concept baru bernama protobuf-ts-types yang memanfaatkan template literal types dari TypeScript untuk menyimpulkan tipe TypeScript dari definisi pesan Protocol Buffer (protobuf) tanpa perlu melakukan pembuatan kode. Meskipun secara teknis mengesankan, pendekatan ini telah memicu perdebatan tentang implikasi praktis dari mendorong sistem tipe TypeScript hingga batasnya.

Sistem Tipe TypeScript sebagai Parser

Pustaka yang dibuat oleh pengembang Nathan Leung ini menggunakan template literal types dari TypeScript untuk mengurai definisi pesan protobuf langsung dalam sistem tipe. Pendekatan ini menghilangkan kebutuhan akan langkah-langkah pembuatan kode terpisah yang biasanya diperlukan ketika bekerja dengan protobuf. Implementasinya cukup ringkas, dengan satu komentator mencatat, Fakta bahwa kodenya sangat kecil itu luar biasa. Saya mengharapkan pustaka parsing yang besar dan rumit yang diimplementasikan dalam tipe.

Yang membuat pendekatan ini sangat menarik adalah bagaimana ia menunjukkan kemampuan sistem tipe TypeScript yang terus berkembang. Pustaka ini pada dasarnya mengimplementasikan parser sepenuhnya dalam sistem tipe TypeScript, menunjukkan bagaimana template literal types dapat digunakan untuk manipulasi string yang kompleks pada level tipe.

Kekhawatiran Performa dan Aplikasi Praktis

Terlepas dari pencapaian teknis, banyak pengembang menyatakan kekhawatiran tentang aplikasi praktis dari pendekatan seperti itu. Masalah utama yang diangkat dalam diskusi adalah dampak performa pada waktu kompilasi dan pengalaman pengembang.

Sangat keren betapa fleksibelnya template literal types, tapi saya tidak bisa membayangkan ingin memiliki trik semacam ini dalam aplikasi produksi yang memperlambat waktu kompilasi.

Sentimen ini digemakan oleh beberapa komentator yang mengkhawatirkan responsivitas IDE dan performa build ketika menggunakan operasi level tipe yang kompleks seperti ini dalam proyek dunia nyata. Meskipun contoh sederhana mungkin berjalan dengan baik, beberapa pengembang mencatat bahwa dalam basis kode yang lebih besar, pendekatan ini dapat secara signifikan menurunkan pengalaman pengembangan.

Keterbatasan dan Pendekatan Alternatif

Pustaka ini memiliki beberapa keterbatasan yang perlu diperhatikan. Saat ini tidak mendukung layanan, RPC, bidang oneof, bidang map, atau impor dari file proto lain. Selain itu, ini memerlukan string proto inline dalam kode TypeScript, yang menciptakan tantangan untuk memelihara definisi proto di beberapa bahasa.

Banyak pengembang dalam diskusi menyarankan bahwa pendekatan pembuatan kode tradisional mungkin masih lebih disukai untuk penggunaan produksi. Alat pembuatan kode menciptakan tipe TypeScript statis yang lebih mudah diproses oleh IDE dan tidak memerlukan komputasi level tipe yang kompleks selama pengembangan.

Beberapa komentator juga menunjukkan bahwa untuk proyek yang hanya menggunakan TypeScript, mendefinisikan tipe langsung di TypeScript mungkin lebih mudah daripada menggunakan protobuf sama sekali, dengan satu orang mencatat mereka lebih suka mendefinisikan tipe di TypeScript dan menghasilkan proto dari itu, karena sistem tipe TypeScript jauh lebih kuat daripada sistem Protobuf.

Keterbatasan Utama dari protobuf-ts-types

• Tidak mendukung service dan rpc (hanya mendukung message)
• Tidak mendukung bidang oneof dan map
• Tidak mendukung import antar file proto
• Memerlukan string proto inline dalam kode TypeScript
• Dapat memengaruhi performa IDE dan waktu kompilasi pada proyek besar
• Masih dalam tahap konsep, belum siap untuk produksi

Evolusi Sistem Tipe TypeScript

Diskusi seputar pustaka ini menyoroti tren yang lebih luas dalam ekosistem TypeScript: sistem tipe semakin digunakan sebagai bahasa pemrograman tersendiri. Beberapa komentator menarik paralel dengan sistem meta-pemrograman lainnya, dengan satu orang mencatat bahwa kita menghabiskan semua upaya ini untuk mengubah sistem tipe preprocessor menjadi metalanguage yang turing-complete.

Evolusi ini memiliki pendukung dan kritikus. Para pendukung menghargai fleksibilitas dan kekuatan yang dibawa fitur tipe lanjutan untuk menggambarkan pola JavaScript yang kompleks. Kritikus khawatir bahwa sistem tipe menjadi terlalu kompleks, yang mengarah pada pesan kesalahan yang membingungkan dan pengalaman pengembang yang buruk.

Satu potensi peningkatan di masa depan yang disebutkan adalah kemungkinan dukungan TypeScript untuk inferensi tipe dalam tagged template literals, yang akan memungkinkan sintaks yang lebih elegan ketika bekerja dengan bahasa domain-spesifik tertanam seperti definisi protobuf.

Sebagai kesimpulan, meskipun protobuf-ts-types menunjukkan pencapaian teknis yang mengesankan dalam kemampuan sistem tipe TypeScript, komunitas tetap terbagi mengenai apakah pendekatan seperti itu praktis untuk pengembangan sehari-hari. Proyek ini berfungsi sebagai proof-of-concept yang menarik dan pemicu diskusi tentang arah evolusi TypeScript.

Referensi: protobuf-ts-types