Berdasarkan grammar yang telah didefinisikan pada artikel [sebelumnya](https://graf.co.id/tutorials/development-dsl-untuk-db-api-modelling-part-2-syntax-grammar), ketika menjalankan parser grammar untuk kode `enum` berikut

```adf
enum UserType {
  Regular
  VIP
}
```

nearley.js mengeluarkan hasil parsing berikut:

```json
[{
  "type": "enum",
  "name": {
    "type": "variable",
    "value": "UserType",
    "text": "UserType",
    "offset": 5,
    "lineBreaks": 0,
    "line": 1,
    "col": 6
  },
  "items": [{
    "type": "variable",
    "value": "Regular",
    "text": "Regular",
    "offset": 18,
    "lineBreaks": 0,
    "line": 2,
    "col": 3
  }, {
    "type": "variable",
    "value": "VIP",
    "text": "VIP",
    "offset": 28,
    "lineBreaks": 0,
    "line": 3,
    "col": 3
  }]
}]
```

berdasarkan hasil tersebut dapat diperkirakan struktur data untuk enum pada **Typescript** seperti berikut:

```ts
import moo from 'moo';

interface Enum {
  type: 'enum'
  name: moo.Token
  items: moo.Token[]
}
```

dengan cara yang sama untuk `table`, `schema`, dan `api` dihasilkan model data berikut

#### Model Basis Data

```ts title="types/model.ts"
import moo from 'moo';

export namespace AST_Model {
  export interface Enum {
    type: 'enum'
    name: moo.Token
    items: moo.Token[]
  }

  export namespace CommonSQLType {
    export interface NoParam {
      kind: 'no-param'
      type: moo.Token
    }

    export interface SingleParam {
      kind: 'single-param'
      type: moo.Token
      p1: moo.Token
    }

    export interface DoubleParam {
      kind: 'double-param'
      type: moo.Token
      p1: moo.Token
      p2: moo.Token
    }

    export interface Relation {
      kind: 'relation'
      name: moo.Token
    }

    export type Types = NoParam | SingleParam | DoubleParam | Relation;
  }

  export namespace ColumnAttribute {
    export interface Nullable {
      type: 'null'
      value: boolean
    }

    export interface PrimaryKey {
      type: 'primary-key'
      value: boolean
    }

    export interface Unique {
      type: 'unique'
      value: boolean
    }

    export interface DefaultValue {
      type: 'default'
      value: {
        type: 'number'
        name: moo.Token
      } | {
        type: 'string'
        name: moo.Token
      } | {
        type: 'enum'
        name: moo.Token
      } | {
        type: 'boolean'
        value: boolean
      }
    }

    export interface AutoIncrement {
      type: 'autoincrement'
      value: boolean
    }

    export type Attributes = Nullable | PrimaryKey | Unique | DefaultValue | AutoIncrement
  }

  export interface TableColumn {
    name: moo.Token
    type: CommonSQLType.Types
    attributes: ColumnAttribute.Attributes[]
  }

  export interface Table {
    type: 'table'
    name: moo.Token
    items: TableColumn[]
  }
}
```

#### Skema Data

```ts title="types/schema.ts"
import moo from 'moo';

export namespace AST_Schema {
  export type NativeOrExistingSchemaOrTable = {
    type: 'native'
    native_type: moo.Token
  } | {
    type: 'table-enum-schema'
    name: moo.Token
  }

  export interface NewSchema {
    type: 'new-schema'
    schema: Schema
  }

  export type ItemType = NativeOrExistingSchemaOrTable | NewSchema

  export interface Item {
    key: moo.Token
    type: ItemType
    required: boolean
    array: boolean
  }

  export interface Schema {
    type: 'schema'
    name: moo.Token
    items: Item[]
  }
}
```

#### API

```ts title="types/api.ts"
import { AST_Schema } from "./schema"
import moo from 'moo';

export namespace AST_API {
  export interface Headers {
    key: moo.Token
    type: AST_Schema.NativeOrExistingSchemaOrTable
    required: boolean
    array?: boolean
  }

  export interface Query {
    key: moo.Token
    type: AST_Schema.NativeOrExistingSchemaOrTable
    required: boolean
    array?: boolean
  }

  export interface Path {
    key: moo.Token
    type: AST_Schema.NativeOrExistingSchemaOrTable
    required: boolean
    array?: boolean
  }

  export interface Body {
    key: moo.Token
    type: AST_Schema.ItemType
    required: boolean
    array?: boolean
  }

  export interface APIItemDescription {
    key: 'description'
    data: moo.Token
  }

  export interface APIItemHeaders {
    key: 'headers'
    data: Headers[]
  }

  export interface APIItemQuery {
    key: 'query'
    data: Query[]
  }

  export interface APIItemPath {
    key: 'path'
    data: Path[]
  }

  export interface APIItemBody {
    key: 'body'
    data: Body[]
  }

  export interface APIItemReturn {
    key: 'return'
    type: AST_Schema.ItemType
    required: boolean
    array?: boolean
  }

  export type APIItem = APIItemDescription
    | APIItemHeaders
    | APIItemQuery
    | APIItemPath
    | APIItemBody
    | APIItemReturn

  export interface API {
    description?: string
    type: 'api'
    method: moo.Token
    path: moo.Token
    items: APIItem[]
  }
}
```

Struktur data hasil parsing nearley tersebut kemudian dikompilasi dalam sebuah fungsi `ast` berikut

```ts title="ast.ts" {10,14-17}
import moo from 'moo';
import nearley from 'nearley';
import { AST_API } from './types/api';
import { AST_Model } from './types/model';
import { AST_Schema } from './types/schema';

export type AST_Item = AST_API.API | AST_Model.Table | AST_Model.Enum | AST_Schema.Schema;

export function ast(code: string): AST_Item[] {
  const grammar = require('../ast/grammar/adf-lang.js');
  const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar));

  parser.feed(code.split('\n').map(x => {
    if (x.trim().startsWith('//')) {
      return '';
    }
    return x;
  }).join('\n'));
  if (parser.results.length > 1) {
    throw new Error(`Syntax ambiguity`);
  }
  return parser.results[0];
}
```
variabel grammar pada baris ke-10 adalah file hasil *compile* grammar nearley berupa file `*.js`. Pada baris 14 sampai 17, seluruh baris yang diawali dengan double slash `//` dianggap sebagai komentar dan diabaikan dari proses parsing.


#### **Selanjutnya**
[Development DSL untuk DB & API Modelling (Part 4 - Semantic Analysis)](https://graf.co.id/tutorials/development-dsl-untuk-db-api-modelling-part-4-semantic-analysis)

#### **Sebelumnya**
[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)

Hasil parsing nearley berikutnya akan menjadi sebuah abstract syntax tree (AST). Nearly menghasilkan struktur data hasil parsing yang masih perlu diproses lagi agar menjadi AST yang diinginkan. Struktur data AST lalu dianalisis terlebih secara semantik pada proses analisis semantik.