Perhatikan coret-coretan model basis data berikut:

```text
+------------------------+
|          User          |
+------------------------+
| id bigint key auto-inc |<---+
| name varchar(500)      |    |   +---------------------------+ 
| address text nullable  |    |   |          Project          | 
+------------------------+    |   +---------------------------+ 
                              |   | id bigint key auto-inc    | 
                              +--$| id_user bigint            | 
                                  | description text nullable | 
                                  +---------------------------+ 
```

kurang lebih menunjukkan informasi mengenai dua buah tabel data dengan masing-masing kolomnya. Jika penulisannya dibuat dalam format YAML, kira-kira menjadi seperti berikut:

```yaml
- table: User
  columns:
    - name: id
      type: bigint
      attributes:
        - primarykey
        - autoincrement
    - name: name
      type: varchar
      length: 500
    - name: address
      type: text
      attibutes:
        - nullable
- table: Project
  columns:
    - name: id
      type: bigint
      attributes:
        - primarykey
        - autoincrement
    - name: id_user
      type: bigint
    - name: description
      type: text
      attibutes:
        - nullable
```

Untuk menuliskan 2 buah tabel dengan masing-masing 3 kolom butuh 27 baris, hmm.. terlalu panjang. Jika ditulis dengan pseudocode, hasilnya lebih padat dan pendek seperti berikut:

```text
table User
- id bigint primarykey autoincrement
- name varchar(500)
- address text nullable

table Project
- id bigint primarykey autoincrement
- id_user bigint
- description text nullable
```

Setelah browsing di internet, ternyata telah ada sebuah domain specific language (DSL) yang mengimplementasikan semacam pseudocode di atas yaitu DBML [https://dbml.dbdiagram.io/home/](https://dbml.dbdiagram.io/home/).

Perhatikan contoh dbml berikut

```dbml
Table users {
  id integer
  username varchar
  role varchar
  created_at timestamp
}

Table posts {
  id integer [primary key]
  title varchar
  body text [note: 'Content of the post']
  user_id integer
  status post_status
  created_at timestamp
}

Enum post_status {
  draft
  published
  private [note: 'visible via URL only']
}

Ref: posts.user_id > users.id // many-to-one
```

Overall very nice, good job to the developer. Cuma ada satu hal yang cukup menganggu, syntax `Ref` pada baris 23 seharusnya dapat disimplifikasi menjadi seperti berikut:

```text {2,12}
Table users {
  id integer
  username varchar
  role varchar
  created_at timestamp
}

Table posts {
  id integer [primary key]
  title varchar
  body text [note: 'Content of the post']
  user_id Table.users.id
  status post_status
  created_at timestamp
}

Enum post_status {
  draft
  published
  private [note: 'visible via URL only']
}
```

Hasilnya lebih sederhana, kolom `user_id` seharusnya langsung dapat meng-inferensi jenis data sesuai jenis data `id` pada tabel `users`. Hal lain yang bisa diperbaiki yaitu dengan membuang karaketer non-alphanumeric semaksimal mungkin. Jika diperhatikan lebih banyak pada aturan syntax DBML, ada terlalu banyak karakter-karakter syntaksis yang mengurangi estetika ke-natural-an bahasa manusianya (mungkin lebih ke preferensi masing-masing developer, saya sendiri prefer DSL harus sedekat mungkin dengan bahasa manusia). [https://dbml.dbdiagram.io/docs](https://dbml.dbdiagram.io/docs)

DBML ternyata memiliki ekosistem yang cukup lengkap, misalnya mereka memiliki generator kode dari DBML ke `postgres`, `mysql`, `mssql`, `snowflake`, dan `bigquery`. Luar biasa... sayangnya tidak ada tools untuk update struktur database. Berdasarkan pengalaman sebelum-sebelumnya, saya sendiri tidak pernah menulis SQL script untuk membuat database atau mengupdate struktur database, dari sisi ke-keren-an, tools DBML keren, dari sisi ke-praktis-an masih kurang praktis.

Loh mengapa? terus seperti apa praktik saat ini? Sebuah library NodeJS bernama TypeORM memiliki fitur autogenerate-migration yang otomatis meng-generate SQL script dari model data TypeORM yang ada. Kelebihannya ketika ada perubahan kolom atau tabel, TypeORM dapat langsung meng-generate SQL script untuk mengakomodasi perubahan tersebut secara otomatis, cukup mudah bukan?

DSL pemodelan basis data harus memiliki fitur semacam TypeORM agar lebih praktis dan dapat digunakan. Perubahan struktur basis data cukup sering terjadi dalam pengembangan software.

Bagaimana jika DSL semacam DBML dibuat agar mengenerate model data untuk TypeORM? Mungkin bisa jadi salah satu solusi, atau mungkin DSL yang akan dibuat ini nantinya dibuat dengan **Developer Experience** yang cukup mudah dipahami lalu kontributor komunitas yang akan membuat kode generator untuk berbagai kebutuhan mereka.

### Angan-angan DSL telah selesai

Misal DSL X tersebut telah selesai dan dapat mengenerate model TypeORM, ternyata akan lebih baik jika terdapat DSL lain lagi yang bisa memfasilitasi aturan berkomunikasi antara sistem yang berbagi data dengan struktur yang sama. Jika berbicara aturan komunikasi atau protokol komunikasi di komputer, maka ada sangat banyak protokol komunikasi `TCP`, `UDP`, `HTTP`, `RTSP`, `WebRTC`, `RPC`, dan lainnya. Untuk membuktikan konsep DSL ini saya akan menggunakan satu protokol saja yaitu **HTTP**.

Protokol HTTP secara sederhana memiliki format seperti berikut:
```text
POST /subscribe HTTP/1.1
Host: api.graf.co.id
Accept: application/json, text/plain, */*
Accept-Language: en-US,en;q=0.9,id;q=0.8
Connection: keep-alive
Content-Type: application/json
Origin: https://graf.co.id
Referer: https://graf.co.id/
Content-Length: 29

{"email":"kontak@graf.co.id"}
```

**Baris #1** menunjukkan metode yang digunakan `POST`, path url tujuan `/subscribe`, dan versi protokol yang digunakan `HTTP/1.1`.

**Baris #2 - #9** adalah header dari request

**Baris #10** spasi pemisah antara request header dan request body

**Baris #11** body request

Terdapat 3 bagian utama yang perlu diperhatikan dari contoh protokol tersebut yaitu:
- **Host+Path**
- **Header**
- **Body**

DSL untuk protokol HTTP berikut harus dapat memfasilitasi 3 bagian di atas. Agar DSL protokol HTTP ini lengkap, jenis data input (HTTP request) dan output (HTTP response) dapat dikaitkan dengan DSL database sebelumnya. Lihat coret-coretan konvensi komunikasi API berikut:

```text
struct LoginResponse {
  token: string
  data: User # struktur data persis dengan tabel User di database
}

API POST https://localhost:3000/login
Body: { username: string, password: string }
Return: LoginResponse

struct ProjectPaginationResponse {
  total: number
  data: Project[] # struktur data persis dengan tabel Project di database
}

API GET https://localhost:3000/projects?limit=<number>&offset=<number>
Return ProjectPaginationResponse
```

Ketika kedua DSL di atas digabung, gambaran pseudocode-nya kurang lebih menjadi seperti berikut:

```text
table User
- id bigint primarykey autoincrement
- name varchar(500)
- address text nullable

table Project
- id bigint primarykey autoincrement
- id_user bigint
- description text nullable

struct LoginResponse
- token string
- data table.User

api POST /login
body:
- username string
- password string
response: LoginResponse

struct ProjectPaginationResponse
- total number
- data arrayof table.Project

api GET /projects
query:
- limit number
- offset number
response: ProjectPaginationResponse
```

DSL di atas akan menjadi sebuah DSL komplit yang dapat:
- mengenerate model basis data baik ke SQL atau model data dari sebuah library seperti TypeORM,
- mengenerate stub API untuk HTTP server,
- mengenerate API driver untuk http request,
- tidak sekedar stub API, mungkin bisa juga digunakan sebagai prompt untuk LLM mengimplementasikan API,
- dan studi kasus lain yang belum terpikirkan.


#### **Selanjutnya**
[Development DSL untuk DB & API Modelling (Part 2 - Syntax Grammar)](https://graf.co.id/tutorials/development-dsl-untuk-db-api-modelling-part-2-syntax-grammar)

Merancang model data dan metode komunikasi antar sistem pengolah data merupakan esensi utama dari sebuah program. Percobaan ini menjelaskan permasalahan yang diselesaikan dari pembuatan DSL (Domain Specific Language) untuk pemodelan basis data dan API.