Pada DSL ini parser didesain menerima input dalam bentuk string, local file, atau file url. Berikut rancangan fungsi yang akan digunakan untuk parser.

```ts
export async function parse(uri: string): Promise<SAResult>
export async function parseString(code: string): Promise<SAResult>
```

fungsi `parse(uri)` menerima masukan dalam bentuk file path atau file url dengan konten berjenis teks standar `UTF-8`, isi file tersebut akan di-parse menghasilkan struktur data `SAResult`.

Fungsi `parseString(code)` kurang lebih sama seperti `parse(uri)`, perbedaannya fungsi `parseString(code)` langsung menerima string kode DSL sebagai masukan.

Implementasi `parseString(code)` kurang lebih seperti berikut:

```ts
import { ast } from "./ast/ast";
import { analyze, SAResult } from './semantic-analysis/sem-analysis';

export async function parseString(code: string): Promise<SAResult> {
  return await analyze(ast(code));
}
```

Pada `parse(uri)`, implementasi akan sedikit lebih banyak dibandingkan `parseString(code)`. `parse(uri)` pertama harus membedakan uri dalam format url file atau local file. Berikut ini regex yang dapat digunakan untuk mendeteksi format url file:

```js
/https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)/
```

Implementasi lengkap untuk `parse(uri)` kurang lebih seperti berikut:

```ts
import { ast } from "./ast/ast";
import { analyze, SAResult } from './semantic-analysis/sem-analysis';
import fs from 'fs';
import axios from 'axios'
import path from 'path'

export async function parse(uri: string): Promise<SAResult> {
  const url_regex = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)/;
  
  if (url_regex.test(uri)) {
    try {
      console.log(`downloading file '${uri}'...`)
      const response = await axios.get<string>(uri, { responseType: 'text' });
      const code = response.data;
      console.log(`download complete.`);
      return await analyze(ast(code));
    } catch (err: any) {
      throw new Error(`from file: '${uri}'\n${err.toString()}`);
    }
  } else {
    const absolute_path = path.resolve(uri);
    try {
      console.log(`file '${absolute_path}'`)
      const readFromFile = (f: string): Promise<string> => new Promise((resolve, reject) => fs.readFile(f, 'utf-8', (err, data: string) => { if (err) reject(err); else resolve(data)}));
      const code = await readFromFile(absolute_path);
      return await analyze(ast(code), path.dirname(absolute_path), current_result, config);
    } catch (err: any) {
      throw new Error(`from file: '${absolute_path}'\n${err.toString()}`);
    }
  }
}
```

Di tahap ini, parser telah selesai diimplementasikan dan siap digunakan untuk menginterpretasikan kode DSL menjadi keluaran struktur data `SAResult`.

### Pembuatan Compiler

Setelah memiliki parser yang utuh, kebutuhan berikutnya adalah membuat compiler DSL ke bentuk yang praktis dan bisa membantu pekerjaan *real* yang ada di dunia kerja. Sesuai motivasi awal pada artikel [pertama](https://graf.co.id/tutorials/development-dsl-untuk-db-api-modelling-part-1-motivasi), sekarang saatnya mencoba DSL ini sebagai masukan untuk membuat generator kode model data TypeORM beserta sesuatu hal yang terkait dengan program HTTP client-server. Tahapan pembuatan compiler ini akan saya bahas di artikel terpisah.

> NB: Saya tidak terlalu yakin apakah fitur penerjemah struktur data `SAResult` menjadi model data TypeORM dapat disebut sebagai compiler atau tidak, sekarang anggap saja istilah tersebut disebut **compiler** (untuk simplifikasi istilah).


#### **Selanjutnya**
[Development DSL untuk DB & API Modelling (Part 6 - Compiler Model TypeORM)](https://graf.co.id/tutorials/development-dsl-untuk-db-api-modelling-part-6-compiler-model-typeorm)

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

Setelah menyelesaikan seluruh proses tokenizer, lexer, parser, dan analisis semantik, sekarang saatnya untuk menyatukan seluruh bagian-bagian tersebut menjadi sebuah parser komplit yang mengeluarkan output informasi penting sesuai tujuan dari bahasa DSL tersebut.