Melihat pseudocode terakhir pada artikel [sebelumnya](https://graf.co.id/tutorials/development-dsl-untuk-db-api-modelling-part-1-motivasi), grammar dari syntax tersebut masih berantakan dan tidak konsisten. Saya memutuskan untuk membuat grammar baru yang lebih konsisten dan juga mudah diimplementasikan.

Grammar dibagi menjadi dua bagian besar:
- Model Basis Data
- Protokol API & Skema Data

### Model Basis Data

```adf {7,18}
enum UserType {
  Regular
  VIP
}

table User {
  id bigint autoincrement primary-key notnull
  fullname varchar(255) notnull
  description text null
  email varchar(255) uniq notnull
  password varchar(255) notnull
  type UserType notnull default=UserType.Regular
  created_at timestamp notnull
}

table Location {
  id bigint pk inc notnull
  id_user User.id notnull
  title varchar(100) notnull
  longitude decimal(8,10)
  latitude decimal(8,10)
  created_at timestamp notnull
}
```

`autoincrement` alias `inc`, `increment`

`primary-key` alias `pk`

`unique` alias `uniq`

terdapat `null` dan `notnull`, secara default seluruh kolom bersifat *nullable* kecuali diberi atribut `notnull`.

Setiap kolom tabel memiliki format berikut

```text
<nama kolom> <jenis data> <attribut1 (opsional)> <attribut2 (opsional)> ...  <attributN (opsional)>
```

Jenis data kolom dapat memiliki parameter, dipisah koma jika parameter lebih dari satu

Default value dapat berisi enumerasi, string, angka, atau boolean (true/false).

Pada baris 7 dan 18, terdapat relasi antar tabel. Jenis data pada foreign key otomatis mengikuti jenis data dari primary key-nya.


### Protokol API dan Skema Data

```adf
schema LoginPayload {
  email string required
  password string required
}

schema LoginResponse {
  token string required
  data table.User required
}

api POST /login {
  body {
    data schema.LoginPayload required
  }
  return schema.LoginResponse required
}

api GET /locations/:id {
  headers {
    authorization string required
  }
  path {
    id number required
  }
  return schema DetailLocationData {
    list_data_1 array number required
    list_data_2 array number
    user table.User required
    location table.Location required
  } required
}
```

skema data (*schema*) akan mengakomodasi struktur data *custom* yang dibutuhkan pada request/response parameter. Seluruh bagian data memiliki format secara umum berikut:

```text
<nama variabel> array? <jenis data> required?
```

secara syntax, seluruh bagian data dapat melakukan referensi ke skema (*schema*) atau tabel basis data (*table*) menggunakan keyword `schema` atau `table` diikuti titik/dot lalu nama skema/tabel. Skema juga dapat dibuat secara inline di dalam `body`, `return`, atau skema lainnya, misalnya:

```adf
schema foo {
  bar schema foo2 {
    bar2 string required
    bar3 string
  } required

  lee schema UserResponse {
    token string required
    data table.User required
  }
}
```

### Token, Lexer, & Parser

Untuk mempermudah proses parsing, saya mendefinisikan beberapa token menggunakan format [no-context/moo](https://github.com/no-context/moo) berikut:

```js title="lexer.js"
module.exports = {
  comment              : /\ *\/\/.*/,
  whitespace           : /[ \t]+/,
  number               : /\-?[0-9]+/,
  double_quoted_string : /"(?:\\["\\]|[^\n"\\])*"/,
  single_quoted_string : /'(?:\\['\\]|[^\n'\\])*'/,
  variable_acccess     : /[A-Za-z\_]\w*\.[A-Za-z\_]\w*/,
  variable             : /[A-Za-z\_][\w\-]*/,
  api_path             : /(?:(?:\/[\w\-\:]+)+|\/)/,
  lparen               : '(',
  rparen               : ')',
  lbrack               : '{',
  rbrack               : '}',
  eq                   : '=',
  dot                  : '.',
  comma                : ',',
  newline              : { match: /\n|\r\n/, lineBreaks: true },
  anyelse              : /./
}
```

lalu saya menggunakan [nearley.js](https://nearley.js.org/) untuk parsing, nearly.js kompatibel dengan tokenizer moo sehingga mempermudah proses penulisan grammar.

Dalam proses penulisan grammar, saya memisahkan satu per satu grammar lalu mengujinya secara terpisah. Seluruh grammar nearley.js kemudian digabung menjadi satu grammar utama seperti berikut:

```nearley
@{%
const moo = require('moo');
const lexer = moo.compile(require('./lexer.js'));
%}

@lexer lexer

main -> item:* __o {% id %}

item -> __o enum {%
          ([_0, _1]) => _1
        %}
      | __o table {%
          ([_0, _1]) => _1
        %}
      | __o schema {%
          ([_0, _1]) => _1
        %}
      | __o api {%
          ([_0, _1]) => _1
        %}
```

Berikut daftar grammar untuk `enum`, `table`, `schema`, dan `api`:

### Grammar: Enum

```nearley
@{%
const moo = require('moo');
const lexer = moo.compile(require('./lexer.js'));
%}

@lexer lexer

main -> enum

enum -> "enum" __r %variable __r %lbrack enum_item:* __o %rbrack {%
  ([_extends, _0, _1, _2, _3, _4, _5]) => ({
    type: 'enum',
    name: _2,
    items: _5
  })
%}

enum_item -> %whitespace:* %newline __o %variable {%
  ([_0, _1, _2, _3]) => _3
%}


__o -> __:*
__r -> __:+

__ -> %whitespace | %newline
everything -> .:*
```

### Grammar: Table

```nearley
@{%
const moo = require('moo');
const lexer = moo.compile(require('./lexer.js'));
%}

@lexer lexer

main -> table

table -> "table" __r %variable __r %lbrack table_item:* __o %rbrack {%
  ([_0, _1, _2, _3, _4, _5]) => ({
    type: 'table',
    name: _2,
    items: _5
  })
%}

table_item -> %whitespace:* %newline __o %variable %whitespace %variable table_item_attribute:* {%
                ([_0, _1, _2, _3, _4, _5, _6]) => ({
                  name: _3,
                  type: {
                    kind: 'no-param',
                    type: _5
                  },
                  attributes: _6
                })
              %}
            | %whitespace:* %newline __o %variable %whitespace table_item_one_param_type table_item_attribute:* {%
                ([_0, _1, _2, _3, _4, _5, _6]) => ({
                  name: _3,
                  type: _5,
                  attributes: _6
                })
              %}
            | %whitespace:* %newline __o %variable %whitespace table_item_two_param_type table_item_attribute:* {%
                ([_0, _1, _2, _3, _4, _5, _6]) => ({
                  name: _3,
                  type: _5,
                  attributes: _6
                })
              %}
            | %whitespace:* %newline __o %variable %whitespace %variable_acccess table_item_attribute:* {%
                ([_0, _1, _2, _3, _4, _5, _6]) => ({
                  name: _3,
                  type: {
                    kind: 'relation',
                    name: _5
                  },
                  attributes: _6
                })
              %}

table_item_attribute -> %whitespace table_item_attribute_default_value {%
                          ([_0, _1]) => _1
                        %}
                      | %whitespace table_item_attribute_general {%
                          ([_0, _1]) => _1
                        %}

table_item_attribute_general -> "notnull" {%
                                  id => ({
                                    type: 'null',
                                    value: false
                                  })
                                %}
                              | "null" {%
                                  id => ({
                                    type: 'null',
                                    value: true
                                  })
                                %}
                              | "autoincrement" {%
                                  id => ({
                                    type: 'autoincrement',
                                    value: true
                                  })
                                %}
                              | "inc" {%
                                  id => ({
                                    type: 'autoincrement',
                                    value: true
                                  })
                                %}
                              | "increment" {%
                                  id => ({
                                    type: 'autoincrement',
                                    value: true
                                  })
                                %}
                              | "primary-key" {%
                                  id => ({
                                    type: 'primary-key',
                                    value: true
                                  })
                                %}
                              | "pk" {%
                                  id => ({
                                    type: 'primary-key',
                                    value: true
                                  })
                                %}
                              | "unique" {%
                                  id => ({
                                    type: 'unique',
                                    value: true
                                  })
                                %}
                              | "uniq" {%
                                  id => ({
                                    type: 'unique',
                                    value: true
                                  })
                                %}

table_item_attribute_default_value -> "default" %eq %double_quoted_string {%
                                        ([_0, _1, _2]) => ({
                                          type: 'default',
                                          value: {
                                            type: 'string',
                                            name: _2
                                          }
                                        })
                                      %}
                                    | "default" %eq %single_quoted_string {%
                                        ([_0, _1, _2]) => ({
                                          type: 'default',
                                          value: {
                                            type: 'string',
                                            name: _2
                                          }
                                        })
                                      %}
                                    | "default" %eq %number {%
                                        ([_0, _1, _2]) => ({
                                          type: 'default',
                                          value: {
                                            type: 'number',
                                            name: _2
                                          }
                                        })
                                      %}
                                    | "default" %eq %variable_acccess {%
                                        ([_0, _1, _2]) => ({
                                          type: 'default',
                                          value: {
                                            type: 'enum',
                                            name: _2
                                          }
                                        })
                                      %}
                                    | "default" %eq "true" {%
                                        ([_0, _1, _2]) => ({
                                          type: 'default',
                                          value: {
                                            type: 'boolean',
                                            value: true
                                          }
                                        })
                                      %}
                                    | "default" %eq "false" {%
                                        ([_0, _1, _2]) => ({
                                          type: 'default',
                                          value: {
                                            type: 'boolean',
                                            value: false
                                          }
                                        })
                                      %}

table_item_one_param_type -> %variable %lparen %whitespace:? %number %whitespace:? %rparen {%
  ([_0, _1, _2, _3, _4, _5, _6, _7]) => ({
    kind: 'single-param',
    type: _0,
    p1: _3,
  })
%}

table_item_two_param_type -> %variable %lparen %whitespace:? %number %whitespace:? %comma %whitespace:? %number %whitespace:? %rparen {%
  ([_0, _1, _2, _3, _4, _5, _6, _7]) => ({
    kind: 'two-param',
    type: _0,
    p1: _3,
    p2: _7,
  })
%}

__o -> __:*
__r -> __:+

__ -> %whitespace | %newline
everything -> .:*
```

### Grammar: Skema Data

```nearley
@{%
const moo = require('moo');
const lexer = moo.compile(require('./lexer.js'));
%}

@lexer lexer

main -> schema

schema -> "schema" __r %variable __r %lbrack schema_item:* __o %rbrack {%
  ([_0, _1, _2, _3, _4, _5]) => ({
    type: 'schema',
    name: _2,
    items: _5
  })
%}

schema_item -> native_var_declaration {% id %}
              | %whitespace:* %newline __o %variable schema_array_indicator:? %whitespace %variable_acccess schema_attribute:? {%
                ([_0, _1, _2, _3, array, _5, _6, required]) => ({
                  key: _3,
                  type: {
                    type: 'table-enum-schema',
                    name: _6
                  },
                  array: array || false,
                  required: required || false
                })
              %}
              | %whitespace:* %newline __o %variable schema_array_indicator:? %whitespace schema schema_attribute:? {%
                ([_0, _1, _2, _3, array, _5, _6, required]) => ({
                key: _3,
                type: {
                    type: 'new-schema',
                    schema: _6
                  },
                  array: array || false,
                  required: required || false
                })
              %}
 
schema_attribute -> %whitespace "required" {%
  ([_0, required]) => Boolean(required)
%}

schema_array_indicator -> %whitespace "array" {%
  ([_0, array]) => Boolean(array)
%}

native_var_declaration -> %whitespace:* %newline __o %variable schema_array_indicator:? %whitespace %variable schema_attribute:? {%
  ([_0, _1, _2, _3, array, _5, _6, required]) => ({
    key: _3,
    type: {
      type: 'native',
      native_type: _6
    },
    array: array || false,
    required: required || false
  })
%}

__o -> __:*
__r -> __:+

__ -> %whitespace | %newline
everything -> .:*
```

### Grammar: API

```nearley
@{%
const moo = require('moo');
const lexer = moo.compile(require('./lexer.js'));
%}

@lexer lexer

main -> api

api -> "api" __r %variable __r %api_path __r %lbrack api_item:* __o %rbrack {%
  ([_0, _1, _2, _3, _4, _5, _6, _7]) => ({
    type: 'api',
    method: _2,
    path: _4,
    items: _7
  })
%}

api_item -> %whitespace:* %newline __o "description" %whitespace everything {%
              ([_0, _1, _2, _3, _4, _5]) => ({
                key: 'description',
                data: _5[0].join('')
              })
            %}
          | %whitespace:* %newline __o "headers" __r %lbrack native_var_declaration:* __o %rbrack {%
              ([_0, _1, _2, _3, _4, _5, _6]) => ({
                key: 'headers',
                data: _6
              })
            %}
          | %whitespace:* %newline __o "path" __r %lbrack native_var_declaration:* __o %rbrack {%
              ([_0, _1, _2, _3, _4, _5, _6]) => ({
                key: 'path',
                data: _6
              })
            %}
          | %whitespace:* %newline __o "query" __r %lbrack native_var_declaration:* __o %rbrack {%
              ([_0, _1, _2, _3, _4, _5, _6]) => ({
                key: 'query',
                data: _6
              })
            %}
          | %whitespace:* %newline __o "body" __r %lbrack schema_item:* __o %rbrack {%
              ([_0, _1, _2, _3, _4, _5, _6]) => ({
                key: 'body',
                data: _6
              })
            %}
          | %whitespace:* %newline __o "return" schema_array_indicator:? %whitespace %variable schema_attribute:? {%
              ([_0, _1, _2, _3, array, _5, _6, _7]) => ({
                key: 'return',
                type: {
                  type: 'native',
                  native_type: _6
                },
                array: array || false,
                required: _7 || false
              })
            %}
          | %whitespace:* %newline __o "return" schema_array_indicator:? %whitespace %variable_acccess schema_attribute:? {%
              ([_0, _1, _2, _3, array, _5, _6, _7]) => ({
                key: 'return',
                type: {
                  type: 'table-enum-schema',
                  name: _6
                },
                array: array || false,
                required: _7 || false
              })
            %}
          | %whitespace:* %newline __o "return" schema_array_indicator:? %whitespace schema schema_attribute:? {%
              ([_0, _1, _2, _3, array, _5, _6, _7]) => ({
                key: 'return',
                type: {
                  type: 'new-schema',
                  schema: _6
                },
                array: array || false,
                required: _7 || false
              })
            %}

# Tambah grammar Skema Data

__o -> __:*
__r -> __:+

__ -> %whitespace | %newline
everything -> .:*
```


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

#### **Sebelumnya**
[Development DSL untuk DB & API Modelling (Part 1 - Motivasi)](https://graf.co.id/tutorials/development-dsl-untuk-db-api-modelling-part-1-motivasi)

Setelah mendefinisikan gambaran solusi dari DSL pemodelan basis data dan API, tahap berikutnya adalah menentukan sintaks yang konsisten dan tidak ambigu untuk DSL tersebut. Syntax DSL ini diimplementasikan menggunakan NodeJS dengan library tokenizer/lexer moo dan parser Nearley untuk menghasilkan Abstract Syntax Tree (AST).