DEV Community: dino

Membuat starter pack project dan sistem autentikasi secara singkat menggunakan AI

dino — Tue, 01 Apr 2025 01:17:00 +0000

Dalam era teknologi saat ini, perkembangan AI berlangsung sangat pesat dan telah menjadi salah satu tren terbesar di dunia programming. Beberapa AI, seperti ChatGPT dan GitHub Copilot, telah menjadi pendamping yang sangat baik bagi programmer/developer. Teknologi ini dapat membantu dalam berbagai tugas sehari-hari, seperti merancang struktur database, memperbaiki bug, membuat fungsi yang lebih efisien, dan masih banyak lagi.

Kali ini, saya mencoba membuat sistem autentikasi dan proyek awal dengan bantuan dua tools AI, yaitu ChatGPT dan GitHub Copilot. Dengan kedua tools tersebut, proses pembuatan proyek awal dan sistem autentikasi menjadi jauh lebih cepat. Bahkan, dalam waktu singkat, saya sudah dapat membuatnya beserta unit test.

Sejauh ini, saya menggunakan TypeScript sebagai bahasa utama dalam pengembangan sistem autentikasi ini.

Tahap awal pembuatan project menggunakan github copilot

Pada tahap awal pembuatan proyek, saya menggunakan GitHub Copilot dengan prompt "buatkan starter pack untuk project Express.js dengan TypeScript." Tidak lama setelah itu, GitHub Copilot langsung membuat struktur direktori untuk proyek Express.js dengan TypeScript.

Selanjutnya, saya mengimplementasikan hasilnya ke dalam folder proyek. Beberapa folder beserta file yang diperlukan berhasil ter-generate dengan baik. Setelah itu, saya mencoba menjalankan server, dan semuanya berjalan dengan lancar.

Saya kemudian melakukan beberapa penyesuaian agar struktur proyek sesuai dengan kebutuhan.

Dengan bantuan GitHub Copilot, dalam waktu singkat saya sudah memiliki starter pack yang proper untuk membangun sistem autentikasi. Ini menghemat banyak waktu karena saya tidak perlu lagi mencari starter pack yang sesuai secara manual di GitHub—cukup dengan satu kali generate, hasilnya sudah bisa langsung digunakan.

Membuat struktur database untuk sistem autentikasi menggunakan chatgpt

Untuk membuat struktur database sistem autentikasi, saya menggunakan ChatGPT. Kenapa memilih ChatGPT? Karena saya sudah lebih terbiasa menggunakannya untuk menghasilkan struktur database. Meskipun sebenarnya, GitHub Copilot juga bisa digunakan untuk keperluan ini, jadi pemilihannya tergantung selera masing-masing.

Saya menggunakan prompt "struktur database untuk membuat API authentication," dan ChatGPT langsung menghasilkan struktur database yang dibutuhkan. Beberapa tabel yang tergenerate antara lain:

users
password_resets
roles
permissions
role_user
permission_role

Dengan struktur database ini, kita sudah memiliki dasar yang cukup untuk membangun sistem autentikasi dengan fitur-fitur seperti:

Login user
Registrasi
Reset password
RBAC (Role-Based Access Control) untuk mengatur hak akses pengguna

Menambahkan konfigurasi database menggunakan sqlite3

Untuk konfigurasi database, saya menggunakan SQLite3 karena proyek ini masih sederhana. SQLite3 cukup praktis karena disimpan secara lokal, dan jika nantinya ingin dikembangkan lebih lanjut, konfigurasi database ini bisa dengan mudah dipindahkan ke sistem yang lebih proper, seperti MySQL atau PostgreSQL.

Saya menggunakan GitHub Copilot dengan prompt "tambahkan pada project ini konfigurasi database dengan SQLite3," dan secara otomatis, Copilot menghasilkan file konfigurasi serta panduan instalasi library yang dibutuhkan.

Pada tahap ini, saya diminta untuk memilih metode ORM antara Knex dan Sequelize di Node.js. Jika melihat popularitasnya di npm, Knex tampaknya lebih banyak digunakan, jadi saya memutuskan untuk memakai Knex sebagai ORM.

Selanjutnya, saya menggunakan GitHub Copilot untuk mengenerate konfigurasi migration dan seeder dengan prompt "buatkan konfigurasi migration dan seeder pada Knex." Hasilnya, file knexfile.js otomatis tergenerate dan siap diimplementasikan ke dalam folder proyek.

Membuat migration menggunakan github copilot berdasarkan struktur database yang telah di generate

Selanjutnya, kita membuat migration menggunakan GitHub Copilot untuk mengenerate migration berdasarkan struktur database yang telah dibuat sebelumnya.

Dari hasil generate sebelumnya, ChatGPT telah menghasilkan query SQL yang bisa digunakan untuk membuat tabel-tabel yang diperlukan. Query tersebut kemudian digunakan sebagai dasar dalam prompt untuk mengenerate migration untuk setiap tabel.

Sebagai contoh, saya menggunakan prompt berikut untuk membuat migration tabel users:

buatkan migration untuk table 
--- 
CREATE TABLE users (
    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    password VARCHAR(255) NOT NULL,
    email_verified_at TIMESTAMP NULL DEFAULT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

Dengan prompt ini, GitHub Copilot berhasil mengenerate file migration untuk tabel users dengan baik. Setelah itu, saya cukup menjalankan perintah knex migrate:latest, dan tabel users otomatis dibuat di database.

Selanjutnya, saya mengimplementasikan semua query untuk dijadikan file migration. Namun, ada beberapa error yang terjadi dalam proses ini, sehingga saya perlu menyesuaikan kembali file migration agar semuanya berjalan dengan lancar.

Membuat seeder user admin

Untuk dapat login ke aplikasi, kita membutuhkan user pertama sebagai admin. Oleh karena itu, kita perlu membuat seeder menggunakan GitHub Copilot.

Proses pembuatan seeder ini mirip dengan pembuatan migration, tetapi saya ingin menambahkan role admin pada user yang dibuat. Oleh karena itu, saya menggunakan prompt berikut:

buatkan seeder untuk user dengan role admin dengan sekema sebagai berikut:
--- 
CREATE TABLE users (
    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    password VARCHAR(255) NOT NULL,
    email_verified_at TIMESTAMP NULL DEFAULT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);  

CREATE TABLE roles (
    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) UNIQUE NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);  

CREATE TABLE role_user (
    user_id BIGINT UNSIGNED NOT NULL,
    role_id BIGINT UNSIGNED NOT NULL,
    PRIMARY KEY (user_id, role_id),
    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
    FOREIGN KEY (role_id) REFERENCES roles(id) ON DELETE CASCADE
);

Dengan menyertakan tabel users, roles, dan role_user dalam prompt, GitHub Copilot dapat mengenerate seeder sesuai dengan kebutuhan kita.

Setelah file seeder berhasil tergenerate, saya mengimplementasikannya ke dalam folder proyek dan menjalankan perintah berikut knex seed:run. Setelah perintah dieksekusi, seeder berhasil dijalankan, dan kini kita sudah memiliki user awal dengan role admin untuk login ke sistem autentikasi.

Implementasi sistem autentikasi menggunakan github copilot

Setelah database dan seeder siap, kita lanjut ke implementasi sistem autentikasi pada proyek. Untuk menjaga struktur kode yang bersih dan terorganisir, saya memutuskan untuk menggunakan repository pattern. Dengan cara ini, kita dapat memisahkan persistence logic dari controller.

Langkah pertama adalah membuat file AuthRepository di dalam folder repositories. Di dalam file AuthRepository, saya membuat fungsi login. Saya menggunakan GitHub Copilot dengan prompt "buatkan fungsi login menggunakan JWT," dan Copilot secara otomatis menghasilkan fungsi login di file AuthRepository, lengkap dengan fungsi untuk AuthController dan route.

Sebelum itu, kita perlu menginstall library JWT dan bcrypt sesuai dengan petunjuk dari GitHub Copilot.

Setelah itu, saya mengimplementasikan kode tersebut ke dalam folder proyek dan menjalankan endpoint login. Saya mencoba login menggunakan email dan password yang telah disediakan dalam seeder. Hasilnya, login berhasil dengan response token JWT yang diterima.

Dengan keberhasilan login ini, kita sudah tahu pola dasar untuk membuat fungsi lainnya, seperti reset password dan registrasi. Kita hanya perlu menggunakan prompt otomatis dari GitHub Copilot untuk menghasilkan fungsi-fungsi tersebut.

Contoh prompt untuk fitur-fitur lain:

Registrasi: "buatkan fungsi registrasi"
Reset Password:

implement reset password dengan mekanisme tabel ini
---
CREATE TABLE password_resets (
email VARCHAR(255) NOT NULL,
token VARCHAR(255) NOT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Membuat unittest

Untuk memastikan bahwa kode yang kita tulis berjalan sesuai harapan dan tetap bekerja dengan benar setelah dilakukan perubahan atau pengembangan lebih lanjut, kita perlu membuat unit test.

Langkah pertama adalah menginstal library dan melakukan konfigurasi unit test pada proyek. Saya menggunakan GitHub Copilot dengan prompt "tambahkan unittest," dan Copilot menyarankan untuk menginstal library Jest. Setelah itu, Copilot juga otomatis mengenerate file jest.config.js yang bisa langsung kita implementasikan ke dalam folder proyek.

Setelah konfigurasi Jest selesai, kita bisa mulai membuat unit test. Untuk membuat unit test pertama, saya menggunakan prompt "Buatkan unittest untuk fungsi login." GitHub Copilot langsung menggenerate file unit test yang sesuai dengan yang kita inginkan. Kemudian, saya mengimplementasikan file tersebut ke dalam folder proyek.

Untuk menjalankan unit test, kita cukup menggunakan perintah jest

Jika ada error, saya sesuaikan kembali kode unit testnya dengan bantuan GitHub Copilot untuk memperbaiki masalah yang muncul. Setelah berhasil menjalankan unit test untuk fungsi login, kita dapat melanjutkan untuk membuat unit test bagi fungsi lainnya, seperti registrasi dan reset password.

Jika terjadi masalah lagi, kita bisa menggunakan file test yang sudah berhasil untuk referensi. Cukup sesuaikan dengan file test pertama dan jalankan kembali unit test-nya, seharusnya semuanya sudah berjalan dengan baik.

Kesimpulan

Pada era ini, AI sangat membantu dalam proses pengembangan sebuah proyek. Yang sebelumnya, tanpa AI, kita mungkin membutuhkan waktu berjam-jam atau bahkan berhari-hari untuk menyelesaikannya. Dengan bantuan AI, kita bisa membuat aplikasi yang proper dan dapat digunakan dalam waktu yang sangat singkat.

Namun, ada baiknya jika kita juga mengerti secara teknis mengenai kode yang dibuat oleh AI. Dengan pemahaman tersebut, kita bisa lebih mudah mengidentifikasi dan memperbaiki masalah yang mungkin muncul, sehingga proses pengembangan dapat berjalan lebih lancar dan efektif.

Cara membuat migrations dengan Goose pada Golang

dino — Thu, 01 Feb 2024 03:36:12 +0000

Migration adalah salah satu aspek yang penting dalam pengembangan perangkat lunak. Ini memungkinkan developer untuk mengelola perubahan struktural dalam database, seperti menambahkan kolom baru, mengubah nama tabel, atau membuat indeks baru dengan cara yang terkelola dan dapat direplikasi dengan mudah.

Goose adalah sebuah alat yang membantu dalam mengelola migration database dengan mudah dan efisien, terutama dalam proyek yang menggunakan bahasa pemrograman Go. Dalam artikel ini, kita akan membahas penggunaan Goose untuk melakukan migration database dalam proyek Go.

Apa itu Goose?

Goose adalah sebuah alat yang terinspirasi dari alat migration database Rails, yaitu ActiveRecord. Ini memungkinkan developer untuk mendefinisikan migration database sebagai file Go yang dapat dijalankan untuk memperbarui schema database. Goose menyediakan alat bantu yang efektif untuk melakukan perubahan struktural pada database dengan aman.

Langkah 1: Install Goose

Pertama-tama, Anda perlu menginstal Goose. Anda dapat melakukannya dengan perintah:

go install github.com/pressly/goose/v3/cmd/goose@latest

Hal ini akan menginstall binary goose kedalam directory $GOPATH/bin

Untuk pengguna macOS Anda bisa lakukannya dengan perintah:

brew install goose

Lebih lengkap bisa baca dokumentasi installation instructions

Langkah 2: Inisialisasi Struktur Project

Buatlah folder goose-migration.

mkdir goose-migration \
    cd goose-migration

Kemudian inisiasi mod module.

go mod init goose-migration

Selanjutnya buat folder config dan file database.go untuk menyimpan konfigurasi koneksi ke database.

mkdir config \
    cd config \
    touch database.go

Copy script konfig dibawah ini ke dalam database.go.

package config

import (
    "database/sql"
    "flag"
    "log"

    _ "github.com/go-sql-driver/mysql"
)

var pool *sql.DB

type DBConfig struct {
    connection string
    hostname   string
    port       string
    user       string
    password   string
    database   string
}

func init() {
    var dbConfig DBConfig

    dbConfig.hostname = "127.0.0.1"
    dbConfig.port = "3307"
    dbConfig.user = "root"
    dbConfig.password = "password"
    dbConfig.database = "goose-migration"
    dbConfig.connection = "mysql"

    consStr := dbConfig.user + ":" + dbConfig.password + "@tcp(" + dbConfig.hostname + ":" + dbConfig.port + ")/" + dbConfig.database + "?parseTime=true"
    dsn := flag.String("dsn", consStr, "connection data source name")
    flag.Parse()

    if len(*dsn) == 0 {
        log.Fatal("missing dsn flag")
    }
    var err error
    pool, err = sql.Open(dbConfig.connection, *dsn)
    if err != nil {
        log.Fatal("unable to use data source name", err)
    }
}

func SQLDBConn() *sql.DB {
    return pool
}

Sesuiakan nilai-nilai dibawah ini, menyesuaikan dengan konfigurasi koneksi yang Anda miliki.

dbConfig.hostname = "127.0.0.1"
dbConfig.port = "3307"
dbConfig.user = "root"
dbConfig.password = "password"
dbConfig.database = "goose-migration"
dbConfig.connection = "mysql"

Penjelasan singkat terkait script konfigurasi diatas:

pool adalah variabel global yang akan menyimpan koneksi database.
DBConfig adalah struktur data yang menyimpan konfigurasi database seperti hostname, port, user, password, dan database yang akan digunakan.
Fungsi init() dijalankan secara otomatis ketika package di-load.
Di dalamnya, kita membuat sebuah variabel dbConfig yang merupakan instans dari DBConfig dan menginisialisasikan nilainya.
Kemudian kita membentuk connection string menggunakan nilai-nilai dari dbConfig.
Flag dsn digunakan untuk menerima data source name dari command line.
Selanjutnya, kita membuka koneksi database menggunakan sql.Open(), dan menyimpan hasilnya ke dalam variabel pool. Jika terjadi error saat membuka koneksi, program akan keluar dengan pesan error.
Fungsi SQLDBConn() digunakan untuk mengembalikan pool koneksi database yang telah dibuat. Hal ini memungkinkan penggunaan koneksi database tersebut di berbagai tempat dalam aplikasi.

Secara keseluruhan, script diatas bertujuan untuk mengatur koneksi ke database MySQL menggunakan Go, dengan memanfaatkan package database/sql dan driver MySQL yang disediakan oleh github.com/go-sql-driver/mysql.

Selanjutnya buatlah folder migrations untuk menyimpan file-file migrations.

Jika masih dalam folder config maka kita kembali ke root folder cd ../ kemudian buat folder migrations

mkdir migrations

Selanjutnya buatlah file main.go untuk menjalankan migration.

touch main.go

Copy script dibawah ini:

package main

import (
    "goose-migration/config"

    "github.com/pressly/goose"
)

func main() {
    sqlDB := config.SQLDBConn()

    if err := goose.SetDialect("mysql"); err != nil {
        panic(err)
    }

    err := goose.Up(sqlDB, "migrations")
    // err := goose.Down(sqlDB, "migrations")
    if err != nil {
        panic(err)
    }
}

Penjelasan terkait script main.go diatas:

Pertama-tama, kita memperoleh koneksi database dengan memanggil fungsi SQLDBConn() dari package config.
Selanjutnya, kita memanggil fungsi goose.SetDialect("mysql") untuk menetapkan dialek SQL yang digunakan, dalam hal ini MySQL.
Kemudian, kita melakukan migration database ke versi terbaru menggunakan fungsi goose.Up(sqlDB, "migrations"). Fungsi ini akan mencari file migration di direktori "migrations" dan menjalankan migration tersebut untuk membawa database ke versi terbaru.
Pilihan lain adalah melakukan rollback migration menggunakan goose.Down(sqlDB, "migrations").

Secara keseluruhan, script diatas bertujuan untuk menjalankan migration database ke versi terbaru menggunakan package goose, dengan memanfaatkan koneksi database yang telah dikonfigurasi sebelumnya.

Setelah kita melakukan inisialisasi awal untuk migration menggunakan goose, maka diharapkan struktur folder akan seperti ini.

goose-migration
├─── config
│    └─── databse.go
├─── migrations
└─── main.go

Langkah 3: Membuat file migration

Gunakan perintah goose untuk membuat file migration baru:

goose -dir migrations create create_users_table sql

Copy query migration ini:

-- +goose Up
-- +goose StatementBegin
CREATE TABLE users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    uuid VARCHAR(36) NOT NULL,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) NOT NULL,
    password VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP NULL
);
-- +goose StatementEnd

-- +goose StatementBegin
INSERT INTO users (`uuid`, `name`, `email`, `password`) VALUES ("3d6ebd8d-6a04-449d-b232-bd1ca3ead0bf", "ADMIN", "admin@admin.com", "$2a$12$eHHwhkiE6/IEE37g1SLHRe5qcj1bTd26JMqRTdMonrY0hpiYSNJEe");
-- +goose StatementEnd

-- +goose Down
-- +goose StatementBegin
DROP TABLE users;
-- +goose StatementEnd

Ketika menjalankan migration untuk menaikkan versi schema dan rollback kembali, dapat dipisahkan dengan pernyataan +goose Up dan +goose Down.

Kita juga dapat menjalankan lebih dari satu query SQL saat melakukan migration up, dengan memisahkannya menggunakan StatementBegin dan mengakhiri dengan StatementEnd, begitu juga sama pada migration rollback. Pada script di atas, kita melakukan dua eksekusi query. Yang pertama adalah untuk membuat tabel "users", sementara yang kedua adalah untuk menyisipkan data user ke dalam tabel "users".

Langkah 4: Menjalankan Migration

Selanjutnya kita bisa menjalankan migrations dengan meng-eksekusi file main.go.

go run .

Maka jika berhasil outputnya akan seperti ini.

2024/01/31 06:55:12 OK    20240131052901_create_users_table.sql
2024/01/31 06:55:12 goose: no migrations to run. current version: 20240131052901

Kesimpulan

Membuat script fungsi untuk menjalankan migration bertujuan untuk memudahkan konfigurasi koneksi database yang kita miliki, dalam hal ini yang telah kita buat adalah dalam file main.go.

Goose adalah alat migration database yang bermanfaat dalam pengembangan aplikasi berbasis Golang. Dengan menggunakan Goose, developer dapat mengelola perubahan schema database dengan lebih terstruktur dan mudah diikuti. Ini membantu memastikan integritas data dan kompatibilitas aplikasi seiring waktu.

Dengan mengikuti langkah-langkah di atas, Anda dapat mulai menggunakan Goose dalam proyek Golang Anda untuk mengelola perubahan schema database dengan efisien. Selamat mencoba!

Check full source code disini: dinobaggio/goose-migration

Cara menggunakan Cobra untuk menjalankan server Golang Gin

dino — Mon, 29 Jan 2024 01:58:31 +0000

Gin dan Cobra adalah dua alat yang populer dalam ekosistem Go (atau Golang) yang dapat digunakan untuk membuat aplikasi CLI (Command Line Interface) dan aplikasi web secara efisien. Dalam artikel ini, kita akan membahas cara menggunakan keduanya untuk membuat aplikasi CLI sederhana dan aplikasi web dengan Go.

Langkah 1: Instalasi Gin dan Cobra

Langkah pertama adalah instalasi Gin dan Cobra, sebelum instalasi Gin dan Cobra buatlah sebuah root folder project kita yang diberi nama gin-cobra.

mkdir gin-cobra
cd gin-cobra

Kemudian inisiasi mod module.

go mod init gin-cobra

Selanjutnya instalasi Gin dan Cobra, jalankan perintah dibawah ini untuk intalasi Gin dan Cobra.

go get \
    github.com/gin-gonic/gin \
    github.com/spf13/cobra/cobra

Setelah proses instalasi selesai, library Gin dan Cobra akan tersedia kedalam aplikasi.

Langkah 2: Membuat Directory dan File-File yang dibutuhkan

Sebelumnya anda telah membuat root folder untuk project yang akan digunakan untuk membuat aplikasi Gin dengan Cobra, tahapan ini adalah untuk membuat directory dan file-file yang akan dibutuhkan untuk menjalankan aplikasi Gin dan Cobra.

Selanjutnya buatlah file main.go file ini adalah entry point untuk menjalankan aplikasi Gin dan Cobra.

touch main.go

Isian awal untuk file main.go adalah sebagai berikut:

package main

func main() {}

Selanjutnya buatlah folder bin dan cmd.

Folder bin berguna untuk minyimpan syntax aplikasi Gin dimana isinya adalah sebuah code untuk menjalankanserver http dengan host localhost dan default port 3000.

Folder cmd berguna untuk menyimpan syntax command line Cobra untuk menjalankan code yang telah dibuat pada folder bin.

Jalankanlah perintah dibawah ini:

mkdir bin \
    cmd

Selanjutnya buatlah file app.go pada folder bin dan file root.go pada folder cmd.

Dimana telah disebutkan sebelumnya file app.go pada folder bin digunakan untuk menyimpan sebuah code untuk menjalankan aplikasi server Gin.

Dan file root.go pada folder cmd untuk menyimpan sebuah code inisiasi awal untuk kebutuhan command line Cobra.

Maka struktur folder akan seperti ini:

gin-cobra
├── bin
│   └── app.go
├── cmd
│   └── root.go
└── main.go

Langkah 3: Membuat Aplikasi Web Gin

Selanjutnya pada file bin/app.go copy code dibawah ini, script ini nantinya bertujuan untuk menjalankan aplikasi server web Gin

package bin

import (
    "fmt"
    "log"
    "net/http"

    "github.com/gin-gonic/gin"
)

type App struct {
    Router *gin.Engine
}

func (a *App) Initialize() {
    a.Router = gin.Default()
    a.setRoutes()
}

// setRoutes sets up the routes for the application.
func (a *App) setRoutes() {
    router := a.Router
    router.GET("/healthcheck", func(c *gin.Context) {
        c.JSON(http.StatusOK, "It's work")
    })
}

// Run starts the application.
func (a *App) Run(addr string) {
    fmt.Println("running", addr)
    err := http.ListenAndServe(addr, a.Router)
    if err != nil {
        log.Panic("Failed to start the server:", err)
    }
}

func NewApp() *App {
    app := App{}
    app.Initialize()

    return &app
}

Berikut adalah penjelasan singkat dari setiap bagian code diatas:

type App struct: Ini adalah sebuah struktur yang mendefinisikan aplikasi. Struktur ini memiliki satu properti yaitu Router yang bertipe *gin.Engine.
func (a *App) Initialize(): Ini adalah method untuk menginisialisasi aplikasi. Method ini membuat router menggunakan gin.Default() dan memanggil method setRoutes() untuk menetapkan rute-rute aplikasi.
func (a *App) setRoutes(): Ini adalah method untuk menetapkan rute-rute aplikasi. Dalam contoh ini, hanya ada satu rute yaitu /healthcheck yang akan merespons dengan pesan "It's work" jika diakses.
func (a *App) Run(addr string): Ini adalah method untuk menjalankan server. Method ini mencetak pesan "running" diikuti dengan alamat server yang sedang berjalan, kemudian memulai server HTTP menggunakan http.ListenAndServe().
func NewApp() *App: Ini adalah fungsi pembuat (constructor) untuk membuat instance baru dari aplikasi. Fungsi ini membuat instance dari App, memanggil method Initialize() untuk menginisialisasinya, dan mengembalikan pointer ke instance tersebut.

Dengan demikian, code diatas membuat sebuah aplikasi web sederhana yang dapat menjalankan server HTTP dengan satu rute /healthcheck yang akan merespons dengan pesan "It's work" jika diakses.

Lankah 4: Membuat Command Line untuk menjalankan server menggunakan Cobra

Kemudian pada file cmd/root.go buatlah sebuah inisiasi awal untuk menjalankan aplikasi command line Cobra, pada file ini kita tidak akan menggunakannya untuk menjalankan server, melainkan file ini hanya bertujuan untuk root awal command line saja.

cd cmd \
    touch root.go

package cmd

import (
    "fmt"
    "os"

    "github.com/spf13/cobra"
)

var rootCmd = &cobra.Command{
    Use:   "gin-cobra",
    Short: "gin-cobra menjalankan sebuah aplikasi server dengan command line",
    Long:  "",
    Run: func(cmd *cobra.Command, args []string) {
        // some code
    },
}

func Execute() {
    if err := rootCmd.Execute(); err != nil {
        fmt.Fprintf(os.Stderr, "Whoops. There was an error while executing your CLI '%s'", err)
        os.Exit(1)
    }
}

Selanjutnya buatlah file serve.go di dalam file ini kita akan membuat sebuah script untuk menjalankan aplikasi web server yang telah kita buat sebelumnya pada file bin/app.go

touch serve.go

Copy code dibawah ini kedalam file cmd/serve.go:

package cmd

import (
    "fmt"
    "gin-cobra/bin"

    "github.com/spf13/cobra"
)

var serveCmd = &cobra.Command{
    Use:   "serve",
    Short: "command untuk menjalankan aplikasi server gin-cobra",
    Long:  "",
    Run: func(cmd *cobra.Command, args []string) {
        app := bin.NewApp()
        port := "3000"
        app.Run(fmt.Sprint(":", port))
    },
}

func init() {
    rootCmd.AddCommand(serveCmd)
}

Berikut adalah penjelasan singkat tentang setiap bagian code diatas:

var serveCmd = &cobra.Command{...}: Ini adalah definisi dari command serve menggunakan library Cobra. Command ini digunakan untuk menjalankan aplikasi server gin-cobra.
func init() {...}: Ini adalah fungsi init() yang digunakan untuk melakukan inisialisasi pada package. Di sini, command serveCmd ditambahkan ke root command (rootCmd) pada file cmd/root.go.

Selanjutnya pada root folder tambahkan script dibawah ini pada file main.go:

package main

import "gin-cobra/cmd"

func main() {
    cmd.Execute()
}

Lankah 5: Menjalankan aplikasi server dengan command line

Pada tahapan ini kita sudah bisa menjalankan sebuah aplikasi server menggunakan command line, cukup jalankan perintah dibawah ini:

go run . serve

Selanjutnya akan muncul log seperti dibawah ini, maka aplikasi server kita sudah berhasil dijalankan.

[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.

[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
 - using env:   export GIN_MODE=release
 - using code:  gin.SetMode(gin.ReleaseMode)

[GIN-debug] GET    /healthcheck              --> gin-cobra/bin.(*App).setRoutes.func1 (3 handlers)
running :3000

Kesimpulan

Dengan menggunakan Cobra dan Gin, Anda dapat dengan mudah membuat aplikasi CLI dan aplikasi web menggunakan Go. Kedua alat ini menyediakan abstraksi yang kuat untuk mempercepat pengembangan dan memungkinkan Anda fokus pada logika bisnis aplikasi Anda.

check full source code disini: dinobaggio/gin-cobra

Cara menggunakan cobra pada golang & membangun aplikasi basis command line

dino — Sat, 27 Jan 2024 10:40:17 +0000

Cobra adalah sebuah library di Golang yang digunakan untuk membuat aplikasi command line (command-line applications) dengan fitur-fitur yang kuat dan ekstensibel. Dengan Cobra, Anda dapat dengan mudah membuat perintah, sub-perintah, dan opsi pada aplikasi command line Golang Anda. Dalam artikel ini, kita akan membahas langkah-langkah dasar dalam menggunakan Cobra untuk mengembangkan aplikasi command line.

Langkah 1: Instalasi Cobra

Langkah pertama adalah menginstal library Cobra. Anda dapat melakukannya dengan menjalankan perintah:

go get -u github.com/spf13/cobra/cobra

Langkah 2: Membuat Folder cmd dan command

Buatlah sebuah folder bernama cmd dan create file dengan nama root.go file tersebut akan menajadi file basis perintah yang akan di eksekusi di awal:

mkdir cmd 
cd cmd
touch root.go

maka struktur folder akan seperti ini:

cobra-app
├── cmd
│   └── root.go
└── main.go

Langkah 3: Membuat command pertama

Buatlah sebuah perintah pertama dan import package Cobra:

package cmd

import (
    "fmt"
    "github.com/spf13/cobra"
    "os"
)

Gunakan fungsi cobra.Command untuk membuat perintah utama:

var rootCmd = &cobra.Command{
  Use:   "cobra-app",
  Short: "Aplikasi command line sederhana dengan Cobra",
  Long:  `Ini adalah contoh aplikasi command line sederhana yang dikembangkan dengan menggunakan Cobra di Golang.`,
  Run: func(cmd *cobra.Command, args []string) {
    // Kode yang akan dijalankan ketika perintah utama dijalankan
    fmt.Println("Halo dari aplikasi command line!")
  },
}

Buatlah fungsi Execute untuk menjalankan perintah pertama yang akan di letakan pada file utama main.go

func Execute() {
    if err := rootCmd.Execute(); err != nil {
        fmt.Fprintf(os.Stderr, "Whoops. There was an error while executing your CLI '%s'", err)
        os.Exit(1)
    }
}

maka full of code pada file root.go akan seperti ini:

package cmd

import (
    "fmt"
    "github.com/spf13/cobra"
    "os"
)

var rootCmd = &cobra.Command{
  Use:   "cobra-app",
  Short: "Aplikasi command line sederhana dengan Cobra",
  Long:  `Ini adalah contoh aplikasi command line sederhana yang dikembangkan dengan menggunakan Cobra di Golang.`,
  Run: func(cmd *cobra.Command, args []string) {
    // Kode yang akan dijalankan ketika perintah utama dijalankan
    fmt.Println("Halo dari aplikasi command line!")
  },
}

func Execute() {
    if err := rootCmd.Execute(); err != nil {
        fmt.Fprintf(os.Stderr, "Whoops. There was an error while executing your CLI '%s'", err)
        os.Exit(1)
    }
}

Langkah 4: Membuat sub command

Buatlah sebuah file greet.go untuk menjalan sub command

touch greet.go

buatlah perintah

package cmd

import (
    "fmt"
    "github.com/spf13/cobra"
)

var greetCmd = &cobra.Command{
  Use:   "greet",
  Short: "Sapa pengguna",
  Run: func(cmd *cobra.Command, args []string) {
    fmt.Println("Halo! Selamat datang di aplikasi command line.")
  },
}

buatlah fungsi init dan tambahkan sub-command greet kedalam root command

NOTE: fungsi init digunakan untuk menjalankan kode inisialisasi sebelum program utama dimulai.

func init() {
    rootCmd.AddCommand(greetCmd)
}

maka full of code pada file greet.go akan seperti ini:

package cmd

import (
    "fmt"
    "github.com/spf13/cobra"
)

var greetCmd = &cobra.Command{
  Use:   "greet",
  Short: "Sapa pengguna",
  Run: func(cmd *cobra.Command, args []string) {
    fmt.Println("Halo! Selamat datang di aplikasi command line.")
  },
}

func init() {
    rootCmd.AddCommand(greetCmd)
}

Langkah 5: Tambahkan root command kedalam main package

Panggilang fungsi Execute pada root command kedalam main.go seperti ini:

package main

import "cobra-app/cmd"

func main() {
    cmd.Execute()
}

Langkah 6: Menjalankan aplikasi

Anda bisa menjalankan aplikasi menggunakan perintah:

go run .

Halo dari aplikasi command line!

dan

go run . greet

Halo! Selamat datang di aplikasi command line.

Kesimpulan

Dengan menggunakan Cobra, Anda dapat dengan mudah membuat aplikasi command line yang terstruktur dan mudah di-maintain. Library ini menyediakan banyak fitur tambahan seperti penanganan sub command, validasi input, dan dokumentasi otomatis. Jadi, mulailah mengintegrasikan Cobra dalam proyek Golang Anda untuk membangun aplikasi command line yang kuat dan bersih.