Merge pull request #114 from liam-hq/add_prism_parser

feat: add prism parser

frontend/packages/cli/src/cli/runPreprocess.ts

@@ -1,6 +1,6 @@
 import fs, { readFileSync } from 'node:fs'
 import path from 'node:path'
-import { parse } from '@liam-hq/db-structure'
+import { parse } from '@liam-hq/db-structure/parser'
 
 export function runPreprocess(inputPath: string, outputDir: string) {
   if (!fs.existsSync(inputPath)) {

frontend/packages/cli/src/cli/smoke.test.ts

@@ -13,7 +13,14 @@ describe('CLI Smoke Test', () => {
   it('should run the CLI command without errors', async () => {
     try {
       const { stdout, stderr } = await execAsync('npx --no-install . help')
-      expect(stderr).toBe('')
+      // NOTE: suppress the following warning:
+      if (
+        !stderr.includes(
+          'ExperimentalWarning: WASI is an experimental feature and might change at any time',
+        )
+      ) {
+        expect(stderr).toBe('')
+      }
       expect(stdout).toMatchInlineSnapshot(`
         "Usage: liam [options] [command]
 
@@ -40,7 +47,14 @@ describe('CLI Smoke Test', () => {
       const { stdout, stderr } = await execAsync(
         'npx --no-install . erd build --input fixtures/input.schema.rb',
       )
-      expect(stderr).toBe('')
+      // NOTE: suppress the following warning:
+      if (
+        !stderr.includes(
+          'ExperimentalWarning: WASI is an experimental feature and might change at any time',
+        )
+      ) {
+        expect(stderr).toBe('')
+      }
       expect(stdout).toBe('')
       const { stdout: lsOutput } = await execAsync('ls ./dist')
       expect(lsOutput.trim().length).toBeGreaterThan(0)

frontend/packages/db-structure/package.json

@@ -3,8 +3,12 @@
   "private": true,
   "version": "0.0.1",
   "type": "module",
-  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./parser": "./dist/parser.js"
+  },
   "dependencies": {
+    "@ruby/prism": "1.2.0",
     "pg-query-emscripten": "5.1.0",
     "valibot": "^1.0.0-beta.5"
   },

frontend/packages/db-structure/src/index.ts

@@ -1,4 +1,3 @@
-export { parse } from './parser/index.js'
 export {
   type DBStructure,
   type Table,

frontend/packages/db-structure/src/parser.ts

@@ -0,0 +1 @@
+export { parse } from './parser/index.js'

frontend/packages/db-structure/src/parser/index.ts

@@ -1,8 +1,9 @@
 import type { DBStructure } from 'src/schema/index.js'
+import { processor as schemarbPrismProcessor } from './schemarb-prism/index.js'
 import { processor as schemarbProcessor } from './schemarb/index.js'
 import { processor as postgresqlProcessor } from './sql/index.js'
 
-type SupportedFormat = 'schemarb' | 'postgres'
+type SupportedFormat = 'schemarb' | 'postgres' | 'schemarb-prism'
 
 // TODO: Add error handling and tests
 export const parse = (
@@ -12,6 +13,8 @@ export const parse = (
   switch (format) {
     case 'schemarb':
       return schemarbProcessor(str)
+    case 'schemarb-prism':
+      return schemarbPrismProcessor(str)
     case 'postgres':
       return postgresqlProcessor(str)
     default:

frontend/packages/db-structure/src/parser/schemarb-prism/index.test.ts

@@ -0,0 +1,170 @@
+import type { Table } from 'src/schema'
+import { aColumn, aDBStructure, aTable } from 'src/schema/factories'
+import { describe, expect, it } from 'vitest'
+import { processor } from '.'
+
+describe(processor, () => {
+  describe('should parse create_table correctry', () => {
+    const userTable = (override?: Partial<Table>) =>
+      aDBStructure({
+        tables: {
+          users: aTable({
+            name: 'users',
+            columns: {
+              id: aColumn({
+                name: 'id',
+                type: 'bigserial',
+                notNull: true,
+                primary: true,
+                unique: true,
+              }),
+              ...override?.columns,
+            },
+          }),
+        },
+      })
+
+    it('not null', async () => {
+      const result = await processor(/* Ruby */ `
+        create_table "users" do |t|
+          t.string "name", null: false
+        end
+      `)
+
+      const expected = userTable({
+        columns: {
+          name: aColumn({
+            name: 'name',
+            type: 'string',
+            notNull: true,
+          }),
+        },
+      })
+
+      expect(result).toEqual(expected)
+    })
+
+    it('nullable', async () => {
+      const result = await processor(/* Ruby */ `
+        create_table "users" do |t|
+          t.string "name", null: true
+        end
+      `)
+
+      const expected = userTable({
+        columns: {
+          name: aColumn({
+            name: 'name',
+            type: 'string',
+            notNull: false,
+          }),
+        },
+      })
+
+      expect(result).toEqual(expected)
+    })
+
+    it('defalt value as string', async () => {
+      const result = await processor(/* Ruby */ `
+        create_table "users" do |t|
+          t.string "name", default: "new user", null: true
+        end
+      `)
+
+      const expected = userTable({
+        columns: {
+          name: aColumn({
+            name: 'name',
+            type: 'string',
+            notNull: false,
+            default: 'new user',
+          }),
+        },
+      })
+
+      expect(result).toEqual(expected)
+    })
+
+    it('defalt value as integer', async () => {
+      const result = await processor(/* Ruby */ `
+        create_table "users" do |t|
+          t.integer "age", default: 30, null: true
+        end
+      `)
+
+      const expected = userTable({
+        columns: {
+          age: aColumn({
+            name: 'age',
+            type: 'integer',
+            notNull: false,
+            default: 30,
+          }),
+        },
+      })
+
+      expect(result).toEqual(expected)
+    })
+
+    it('defalt value as boolean', async () => {
+      const result = await processor(/* Ruby */ `
+        create_table "users" do |t|
+          t.boolean "active", default: true, null: true
+        end
+      `)
+
+      const expected = userTable({
+        columns: {
+          active: aColumn({
+            name: 'active',
+            type: 'boolean',
+            notNull: false,
+            default: true,
+          }),
+        },
+      })
+
+      expect(result).toEqual(expected)
+    })
+
+    it('primary key as args', async () => {
+      const result = await processor(/* Ruby */ `
+        create_table "users", id: :bigint
+      `)
+
+      const expected = userTable({
+        columns: {
+          id: aColumn({
+            name: 'id',
+            type: 'bigint',
+            notNull: true,
+            primary: true,
+            unique: true,
+          }),
+        },
+      })
+
+      expect(result).toEqual(expected)
+    })
+
+    it('unique', async () => {
+      const result = await processor(/* Ruby */ `
+        create_table "users" do |t|
+          t.string "name", unique: true
+        end
+      `)
+
+      const expected = userTable({
+        columns: {
+          name: aColumn({
+            name: 'name',
+            type: 'string',
+            unique: true,
+          }),
+        },
+      })
+
+      expect(result).toEqual(expected)
+    })
+  })
+})

frontend/packages/db-structure/src/parser/schemarb-prism/index.ts

@@ -0,0 +1 @@
+export { processor } from './parser'