AST yang dihasilkan pada artikel [sebelumnya](https://graf.co.id/tutorials/development-dsl-untuk-db-api-modelling-part-3-abstract-syntax-tree) sekarang masuk ke tahap analisis semantik. Analisis semantik bertujuan memastikan AST hasil parsing tidak melanggar aturan bahasa DSL yang tidak ter-cover secara syntax pada proses parsing. Pada lexer yang dibahas di bagian artikel [syntax & grammar](https://graf.co.id/tutorials/development-dsl-untuk-db-api-modelling-part-2-syntax-grammar), token `variable` digunakan sebagai tokenizer untuk mengidentifikasi variabel termasuk nama enum, tabel, api, dan beberapa lagi lainnya  dengan *regex* `/[A-Za-z\_][\w\-]*/`. Regex token `variable` tersebut mengijinkan karakter `-` untuk ada pada nama variable, sedangkan pada nama tabel karakter `-` seharusnya tidak diijinkan (*illegal*). Disinilah analisis semantik bertujuan mencegah kesalahan tersebut terjadi dan memunculkan pesan error bahwa ada kesalahan semantik pada syntax. **Mengapa nama tabel tidak diberikan token berbeda dari nama variabel?** Jawabannya karena saya cukup malas untuk membuat token khusus untuk nama tabel dan juga nama tabel merupakan subset dari nama variabel tanpa karakter `-`, saya pikir dicegat saat analisis semantik merupakan solusi tercepat saat ini.

Terdapat empat bagian yang perlu dianalisis pada proses ini:
- Enum
- Tabel
- Skema Data
- API

### Analisis Semantik: Enum

Pada enum hal yang perlu dicegah adalah penggunaan nama enum yang sama pada sebuah kode program dan pengecekan pada sebuah enum apakah terdapat item enum dengan nama yang sama atau tidak. Jika diimplementasikan dalam kode **Typescript**, maka kurang lebih seperti berikut:

```ts
const list_enum: Model.Enum[] = [];
for (const ast_enum of list_ast_enum as AST_Model.Enum[]) {
  if (ast_enum.name.text.includes('-')) {
    throw new Error(`Error line ${ast_enum.name.line} col ${ast_enum.name.col + ast_enum.name.text.indexOf('-')}: enum name '${ast_enum.name.text}' contains illegal character '-'`);
  }

  const existing_enum_index: number = list_enum.findIndex((e: Model.Enum) => e.name === ast_enum.name.text);
  if (existing_enum_index > -1) {
    throw new Error(`Error line ${ast_enum.name.line} col ${ast_enum.name.col + ast_enum.name.text.indexOf('-')}: enum '${ast_enum.name.text}' already defined before`);
  }

  list_enum.push({
    name: ast_enum.name.text,
    type: 'enum',
    items: ast_enum.items.map(t => t.text)
  });
}
```

### Analisis Semantik: Tabel

Selain nama tabel, ada banyak aturan yang perlu dicek pada setiap item kolom tabel. Perhatikan contoh implementasi analisis semantik untuk tabel di bawah:

```ts {7}
const list_table: Model.Table[] = [];
for (const ast_table of list_ast_table as AST_Model.Table[]) {
  if (ast_table.name.text.includes('-')) {
    throw new Error(`Error line ${ast_table.name.line} col ${ast_table.name.col + ast_table.name.text.indexOf('-')}: table name '${ast_table.name.text}' contains illegal character '-'`);
  }

  const list_fields = getTableFields(ast_table, list_ast_table, list_enum, list_table, config);
  const existing_table_index: number = list_table.findIndex((t: Model.Table) => t.name === ast_table.name.text);
  if (existing_table_index > -1) {
    throw new Error(`Error line ${ast_table.name.line} col ${ast_table.name.col + ast_table.name.text.indexOf('-')}: table '${ast_table.name.text}' already defined before`);
  }

  const table: Model.Table = {
    name: ast_table.name.text,
    type: 'table',
    columns: list_fields
  };
  list_table.push(table);
}
```

terdapat sebuah fungsi `getTableFields` dengan parameter seperti berikut:

```ts
function getTableFields(
  ast_table: AST_Model.Table, 
  list_ast_table: AST_Model.Table[], 
  list_enum: Model.Enum[], 
  list_table: Model.Table[]
): Model.TableColumn
```

fungsi di atas menerjemahkan AST menjadi output parsing ke struktur data yang lebih padat dan praktis digunakan. Proses yang dilakukan pada fungsi tersebut antara lain:
- mengecek duplikasi nama kolom
- memisahkan jenis kolom native, enum, dan relasi
- mengekstrak data attribut setiap kolom
- memvalidasi nilai default value terhadap jenis data pada kolom terkait

struktur output dari model Enum dan Tabel akan berbentuk seperti berikut:

```ts
export namespace Model {
  export interface Enum {
    name: string
    type: 'enum'
    items: string[]
  }

  export namespace CommonSQLType {
    export type NoParamsType = 'tinyint'
      | 'smallint'
      | 'int'
      | 'bigint'
      | 'float'
      | 'real'
      | 'boolean'
      | 'date'
      | 'timestamp'
      | 'text'
      | 'decimal'
      | 'varchar';

    export interface Common {
      kind: 'common'
      type: NoParamsType
    }

    export interface Decimal {
      kind: 'decimal'
      type: 'decimal'
      precision?: number
      scale?: number
    }

    export interface Chars {
      kind: 'chars'
      type: 'varchar'
      size?: number
    }

    export interface Enum {
      kind: 'enum'
      type: 'enum'
      enum_name: string
    }

    export interface Relation {
      kind: 'relation'
      type: 'relation'
      table_name: string
      foreign_key: string
    }

    export type Types = Common | Decimal | Chars | Enum | 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 type DefaultValueType = {
      type: 'enum',
      enum_name: string
      enum_value: string
    } | {
      type: 'string',
      data: string
    } | {
      type: 'number',
      data: number
    } | {
      type: 'boolean',
      data: boolean
    };

    export interface DefaultValue {
      type: 'default'
      value: DefaultValueType
    }

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

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

  export interface TableColumn {
    name: string
    description?: string
    type: CommonSQLType.Types
    attributes?: ColumnAttribute.Attributes[]
  }

  export interface Table {
    type: 'table'
    name: string
    columns: TableColumn[]
  }

  export type Item = Table | Enum;
}
```

### Analisis Semantik: Skema Data

Dikarenakan skema data berhubungan erat dengan model Enum dan Tabel, sehingga proses pengecekan konflik nama perlu dilakukan cross-check ke Enum dan Tabel juga. Proses analisis skema salah satuanya untuk memastikan apakah jenis external enum, tabel, atau skema lain tersedia (di deklarasikan pada kode dsl tersebut). Pada analisis skema data juga dilakukan pembuatan skema baru jika ditemukan deklarasi skema secara inline sebagai jenis data di item skema data.

Output struktur data dari skema sebagai berikut:

```ts
export namespace Schema {
  export type NativeType = 'string' | 'number' | 'boolean';

  export type NativeOrSchemaOrTable = {
    type: 'native'
    native_type: Schema.NativeType
  } | {
    type: 'schema'
    schema_name: string
  } | {
    type: 'table'
    table_name: string
  } | {
    type: 'enum'
    enum_name: string
  }

  export interface Item {
    key: string
    type: NativeOrSchemaOrTable
    required?: boolean
    array?: boolean
  }

  export interface Schema {
    type: 'schema'
    name: string
    items: Item[]
  }
}
```

### Analisis Semantik: API

Pada grammar syntax, API method diesktrak sebagai token `variable` yang artinya perlu dibatasi kemungkinannya. Saat ini method hanya berlaku untuk `POST`, `GET`, `PUT`, `PATCH`, dan `DELETE` saja. Analisis yang dilakukan pada API meliputi:
- ekstraksi setiap komponen token sesuai aturan semantik protokol HTTP (misalnya, pada protokol HTTP request body pada method GET akan diabaikan, sehingga pada DSL ini data body juga diabaikan jika ditemukan) 
- pengecekan konflik api path
- pengecekan eksistensi skema dan tabel
- pengecekan jenis data yang dipassing pada setiap komponen HTTP header, body, query, path (misalnya, pada query jenis data yang diijinkan hanya jenis data native saja tidak boleh tabel atau skema data)
- pembuatan skema baru jika terdapat deklarasi skema baru sebagai jenis data pada body atau return value API

Output struktur data dari API sebagai berikut:

```ts
import { Schema } from "./schema"

export namespace API {
  export interface Headers {
    key: string
    type: Schema.NativeType
    required?: boolean
  }

  export interface Query {
    key: string
    type: Schema.NativeType
    required?: boolean
    array?: boolean
  }

  export interface Path {
    key: string
    type: 'string' | 'number' | 'boolean'
  }

  export interface Body {
    key: string
    type: Schema.NativeOrSchemaOrTable
    required?: boolean
    array?: boolean
  }

  export interface ErrorType {
    type: Schema.NativeOrSchemaOrTable
    required?: boolean
    array?: boolean
  }

  interface CommonAPIData {
    description?: string
    path: string
    headers?: Headers[]
    paths?: Path[]
    queries?: Query[]
    error_type?: ErrorType
    return: ReturnType
  }

  export interface ReturnType {
    type: Schema.NativeOrSchemaOrTable
    required?: boolean
    array?: boolean
  }

  export interface GET extends CommonAPIData {
    type: 'api'
    method: 'get'
  }

  export interface POST extends CommonAPIData {
    type: 'api'
    method: 'post'
    body?: Body[]
  }

  export interface PUT extends CommonAPIData {
    type: 'api'
    method: 'put'
    body?: Body[]
  }

  export interface DELETE extends CommonAPIData {
    type: 'api'
    method: 'delete'
  }

  export interface PATCH extends CommonAPIData {
    type: 'api'
    method: 'patch'
    body?: Body[]
  }
  
  export type API = GET | POST | PUT | DELETE | PATCH;
}
```

### Kompilasi Analisis Semantik

Hasil kompilasi dari seluruh implementasi semantik analisis kurang lebih seperti berikut:

```ts
export interface SAResult {
  list_enum: Model.Enum[]
  list_table: Model.Table[]
  list_schema: Schema.Schema[]
  list_api: API.API[]
}

export async function analyze(list_ast: AST_Item[]): Promise<SAResult> {
  const list_ast_enum = list_ast.filter(e => e.type === 'enum');
  const list_ast_table = list_ast.filter(e => e.type === 'table');
  const list_ast_schema = list_ast.filter(e => e.type === 'schema');
  const list_ast_api = list_ast.filter(e => e.type === 'api');

  const result_enum_table = analyzeModel(list_ast_enum, list_ast_table);
  const result_schema = analyzeSchema(list_ast_schema, list_ast_table, list_ast_enum);
  const result_api = analyzeAPI(list_ast_api, result_schema);

  return {
    list_enum: result_enum_table.list_enum,
    list_table: result_enum_table.list_table,
    list_schema: result_api.list_schema,
    list_api: result_api.list_api
  };
}
```


#### **Selanjutnya**
[Development DSL untuk DB & API Modelling (Part 5 - Full Parser)](https://graf.co.id/tutorials/development-dsl-untuk-db-api-modelling-part-5-full-parser)

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

Analisis Semantik merupakan tahap validasi AST sesuai aturan yang telah ditentukan. Analisis semantik disini bertujuan menyediakan AST yang telah memenuhi tujuan awal dari bahasa DSL. Hasil analisis semantik nantinya siap digunakan untuk kebutuhan generator kode program.