DENO CLI-TOOLS DEVELOPER-PRODUCTIVITY TYPESCRIPT CROSS-PLATFORM AUTOMATION WORKFLOW JAVASCRIPT TOOLING BACKEND FULLSTACK

Membangun Command Line Interface (CLI) Tool dengan Deno: Produktivitas Developer Lintas Platform

⏱️ 7 menit baca
👨‍💻

Membangun Command Line Interface (CLI) Tool dengan Deno: Produktivitas Developer Lintas Platform

1. Pendahuluan

Sebagai developer web, kita sering berhadapan dengan tugas-tugas berulang: menjalankan build, mengelola file, berinteraksi dengan API, atau bahkan memproses data. Meskipun task runner seperti npm scripts atau Makefiles bisa membantu, terkadang kita butuh sesuatu yang lebih powerful, fleksibel, dan terstruktur – sebuah Command Line Interface (CLI) tool kustom.

CLI tool kustom adalah sahabat terbaik developer untuk mengotomatisasi workflow, menstandarisasi proses, dan meningkatkan produktivitas tim. Bayangkan Anda bisa menjalankan my-project init untuk setup proyek baru, atau my-tool deploy --env=staging untuk rilis aplikasi dengan satu perintah saja. Keren, kan?

Di ekosistem JavaScript/TypeScript, Node.js adalah pilihan populer untuk membangun CLI. Namun, ada pendatang baru yang semakin matang dan menawarkan keunggulan menarik untuk pengembangan CLI: Deno. Dalam artikel ini, kita akan menyelami mengapa Deno adalah pilihan yang brilian untuk CLI tool Anda, dan bagaimana membangunnya dari nol hingga menjadi executable tunggal yang siap didistribusikan ke berbagai platform.

🎯 Tujuan kita hari ini adalah:

Mari kita mulai petualangan kita!

2. Mengapa Deno untuk CLI Tools Anda?

Deno, singkatan dari “DEvelopment NOde”, diciptakan oleh Ryan Dahl (pencipta Node.js juga!) dengan tujuan mengatasi beberapa kekurangan fundamental di Node.js. Untuk pengembangan CLI, Deno membawa beberapa keunggulan signifikan:

a. TypeScript Out-of-the-Box (OOTB)

💡 Salah satu fitur paling menonjol dari Deno adalah dukungan TypeScript secara native. Anda tidak perlu lagi mengkonfigurasi tsconfig.json atau menggunakan transpiler seperti Babel. Cukup tulis kode TypeScript Anda, dan Deno akan menjalankannya. Ini sangat meningkatkan developer experience dan kualitas kode, terutama untuk proyek CLI yang lebih kompleks.

b. Security by Default

⚠️ Deno menjalankan semua kode dalam sandbox secara default. Ini berarti CLI tool Anda tidak memiliki akses ke file system, jaringan, atau environment variables tanpa izin eksplisit dari pengguna. Misalnya, jika CLI Anda perlu membaca file, Anda harus memberikannya izin deno run --allow-read main.ts. Ini adalah lapisan keamanan yang sangat berharga, terutama saat menggunakan dependensi pihak ketiga.

c. Single Executable Compilation

✅ Ini adalah killer feature untuk distribusi CLI. Dengan satu perintah (deno compile), Anda bisa mengubah kode Deno Anda menjadi satu file executable mandiri yang bisa dijalankan di berbagai sistem operasi (Windows, macOS, Linux) tanpa perlu menginstal Deno runtime terlebih dahulu. Bayangkan betapa mudahnya mendistribusikan CLI Anda ke tim atau pengguna!

d. Standard Library yang Lengkap

Deno memiliki deno.land/std, sebuah standard library yang menyediakan modul-modul esensial untuk tugas-tugas umum seperti manipulasi file, penanganan HTTP, parsing argumen, dan banyak lagi. Ini mengurangi ketergantungan pada modul pihak ketiga dan memastikan konsistensi.

e. Ekosistem yang Modern

Deno didasarkan pada standar web dan menggunakan URL untuk mengimpor modul (seperti di browser). Ini mendorong praktik modularitas yang baik dan mempermudah pengelolaan dependensi.

Dengan semua keunggulan ini, Deno menjadi kandidat yang sangat kuat untuk proyek CLI Anda, terutama jika Anda mencari produktivitas tinggi, keamanan, dan kemudahan distribusi.

3. Persiapan Lingkungan Deno

Sebelum kita mulai coding, pastikan Anda sudah menginstal Deno di sistem Anda.

a. Instalasi Deno

Anda bisa menginstal Deno dengan berbagai cara. Berikut adalah metode yang paling umum:

macOS/Linux (menggunakan Shell):

curl -fsSL https://deno.land/x/install/install.sh | sh

Windows (menggunakan PowerShell):

irm https://deno.land/install.ps1 | iex

Setelah instalasi, verifikasi dengan menjalankan:

deno --version

Anda akan melihat versi Deno, V8, dan TypeScript yang terinstal.

b. Struktur Proyek Dasar

Mari buat folder proyek baru dan file mod.ts (konvensi Deno untuk “main module”):

mkdir my-deno-cli
cd my-deno-cli
touch mod.ts

Sekarang, buka mod.ts di editor favorit Anda.

4. Membangun CLI Sederhana: “Halo Dunia Deno CLI”

Kita akan mulai dengan CLI paling sederhana yang mencetak pesan “Halo, [Nama]!”

// my-deno-cli/mod.ts

// Impor modul `parse` dari standard library Deno untuk parsing argumen CLI.
// Ini adalah cara Deno mengelola dependensi: impor langsung dari URL.
import { parse } from "https://deno.land/std@0.210.0/flags/mod.ts";

// Fungsi utama CLI
function main() {
  // `Deno.args` adalah array string yang berisi semua argumen yang dilewatkan ke CLI.
  // Misalnya, jika Anda menjalankan `deno run mod.ts --name John Doe`,
  // `Deno.args` akan menjadi `["--name", "John", "Doe"]`.
  const args = parse(Deno.args);

  // Ambil nilai dari argumen `--name` atau gunakan 'Dunia' sebagai default.
  const name = args.name || "Dunia";

  console.log(`Halo, ${name}! Selamat datang di Deno CLI Anda.`);

  // Jika ada argumen `--verbose`, cetak semua argumen yang diterima.
  if (args.verbose) {
    console.log("\n📌 Argumen yang diterima:");
    console.log(args);
  }
}

// Panggil fungsi utama saat script dijalankan.
main();

Untuk menjalankan CLI ini, Anda perlu memberikan izin allow-run (jika menggunakan parse yang mungkin memicu beberapa internal Deno, meskipun untuk flags biasanya tidak perlu allow-run tapi allow-env atau allow-read jika argumennya dari file/env). Untuk parsing argumen sederhana, seringkali tidak butuh izin khusus, namun ada baiknya terbiasa dengan konsep --allow-*.

Jalankan CLI Anda:

deno run mod.ts
# Output: Halo, Dunia! Selamat datang di Deno CLI Anda.

deno run mod.ts --name "Budi"
# Output: Halo, Budi! Selamat datang di Deno CLI Anda.

deno run mod.ts --name "Ani" --verbose
# Output:
# Halo, Ani! Selamat datang di Deno CLI Anda.
#
# 📌 Argumen yang diterima:
# { _: [], name: "Ani", verbose: true }

Mudah, kan? Dengan Deno.args dan std/flags, Anda sudah bisa membuat CLI yang interaktif.

5. Interaksi dengan File System dan Jaringan

Kebanyakan CLI tool perlu berinteraksi dengan file lokal atau mengambil data dari jaringan. Deno menyediakan API yang intuitif untuk ini, namun dengan penekanan pada keamanan.

a. Membaca/Menulis File

Mari kita buat CLI yang bisa membaca isi file.

// my-deno-cli/read_file.ts
import { parse } from "https://deno.land/std@0.210.0/flags/mod.ts";

async function readFileCli() {
  const args = parse(Deno.args);
  const filePath = args._[0]; // Ambil argumen pertama sebagai path file

  if (!filePath || typeof filePath !== 'string') {
    console.error("❌ Penggunaan: deno run --allow-read read_file.ts <path_file>");
    Deno.exit(1); // Keluar dengan kode error
  }

  try {
    console.log(`✅ Membaca file: ${filePath}`);
    const content = await Deno.readTextFile(filePath);
    console.log("\n--- ISI FILE ---");
    console.log(content);
    console.log("----------------\n");
  } catch (error) {
    if (error instanceof Deno.errors.NotFound) {
      console.error(`❌ Error: File '${filePath}' tidak ditemukan.`);
    } else if (error instanceof Deno.errors.PermissionDenied) {
      console.error(`❌ Error: Izin ditolak untuk membaca file '${filePath}'.`);
      console.error("   Coba jalankan dengan '--allow-read'.");
    } else {
      console.error(`❌ Terjadi kesalahan: ${error.message}`);
    }
    Deno.exit(1);
  }
}

readFileCli();

Buat file contoh:

echo "Ini adalah konten dari file contoh saya." > example.txt

Coba jalankan tanpa izin:

deno run read_file.ts example.txt
# Output: ❌ Error: Izin ditolak untuk membaca file 'example.txt'.
#            Coba jalankan dengan '--allow-read'.

Seperti yang Anda lihat, Deno memblokir akses file secara default. Anda harus memberikannya izin:

deno run --allow-read read_file.ts example.txt
# Output:
# ✅ Membaca file: example.txt
#
# --- ISI FILE ---
# Ini adalah konten dari file contoh saya.
# ----------------

b. Mengambil Data dari Jaringan (HTTP)

CLI seringkali perlu berinteraksi dengan API eksternal. Deno mendukung Fetch API secara native, mirip dengan browser.

// my-deno-cli/fetch_data.ts
import { parse } from "https://deno.land/std@0.210.0/flags/mod.ts";

async function fetchDataCli() {
  const args = parse(Deno.args);
  const url = args._[0] || "https://jsonplaceholder.typicode.com/todos/1"; // Default URL

  if (typeof url !== 'string') {
    console.error("❌ Penggunaan: deno run --allow-net fetch_data.ts [URL]");
    Deno.exit(1);
  }

  try {
    console.log(`✅ Mengambil data dari: ${url}`);
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data = await response.json();
    console.log("\n--- DATA DARI API ---");
    console.log(JSON.stringify(data, null, 2));
    console.log("---------------------\n");
  } catch (error) {
    if (error instanceof Deno.errors.PermissionDenied) {
      console.error(`❌ Error: Izin jaringan ditolak untuk '${url}'.`);
      console.error("   Coba jalankan dengan '--allow-net'.");
    } else {
      console.error(`❌ Terjadi kesalahan saat mengambil