Initial commit

packages/prisma-parser/src/__tests__/parser.test.ts

@@ -0,0 +1,192 @@
+import { describe, it, expect } from 'vitest';
+import { parsePrismaSchema, detectPrismaVersion, validatePrismaSchema } from '../index';
+
+describe('Prisma Schema Parser', () => {
+  it('should parse a basic Prisma 5 schema', async () => {
+    const schema = `
+      datasource db {
+        provider = "postgresql"
+        url      = env("DATABASE_URL")
+      }
+
+      generator client {
+        provider = "prisma-client-js"
+      }
+
+      model User {
+        id    Int     @id @default(autoincrement())
+        email String  @unique
+        name  String?
+      }
+    `;
+
+    const result = await parsePrismaSchema(schema);
+
+    expect(result.version).toBe(5);
+    expect(result.models).toHaveLength(1);
+    expect(result.models[0].name).toBe('User');
+    expect(result.models[0].fields).toHaveLength(3);
+  });
+
+  it('should detect Prisma 6 features', () => {
+    const schema = `
+      datasource db {
+        provider = "postgresql"
+        url      = env("DATABASE_URL")
+      }
+
+      model User {
+        id       Int    @id
+        password String @omit
+      }
+    `;
+
+    expect(detectPrismaVersion(schema)).toBe(6);
+  });
+
+  it('should detect Prisma 7 features', () => {
+    const schema = `
+      datasource db {
+        provider = "postgresql"
+        url      = env("DATABASE_URL")
+      }
+
+      generator client {
+        provider = "prisma-client"
+      }
+
+      model User {
+        id Int @id
+      }
+    `;
+
+    expect(detectPrismaVersion(schema)).toBe(7);
+  });
+
+  it('should handle relations correctly', async () => {
+    const schema = `
+      datasource db {
+        provider = "postgresql"
+        url      = env("DATABASE_URL")
+      }
+
+      model User {
+        id    Int    @id
+        posts Post[]
+      }
+
+      model Post {
+        id       Int  @id
+        author   User @relation(fields: [authorId], references: [id])
+        authorId Int
+      }
+    `;
+
+    const result = await parsePrismaSchema(schema);
+
+    const userModel = result.models.find((m) => m.name === 'User');
+    const postModel = result.models.find((m) => m.name === 'Post');
+
+    expect(userModel?.fields.find((f) => f.name === 'posts')?.kind).toBe('object');
+    expect(postModel?.fields.find((f) => f.name === 'author')?.relationFromFields).toEqual([
+      'authorId',
+    ]);
+  });
+
+  it('should parse enums correctly', async () => {
+    const schema = `
+      datasource db {
+        provider = "postgresql"
+        url      = env("DATABASE_URL")
+      }
+
+      enum Role {
+        ADMIN
+        USER
+        GUEST
+      }
+
+      model User {
+        id   Int  @id
+        role Role @default(USER)
+      }
+    `;
+
+    const result = await parsePrismaSchema(schema);
+
+    expect(result.enums).toHaveLength(1);
+    expect(result.enums[0].name).toBe('Role');
+    expect(result.enums[0].values).toHaveLength(3);
+    expect(result.enums[0].values.map((v) => v.name)).toEqual(['ADMIN', 'USER', 'GUEST']);
+  });
+
+  it('should validate schema correctly', () => {
+    const validSchema = `
+      datasource db {
+        provider = "postgresql"
+        url = env("DATABASE_URL")
+      }
+
+      model User {
+        id Int @id
+      }
+    `;
+
+    const invalidSchema = `
+      model User {
+        id Int @id
+    `;
+
+    expect(validatePrismaSchema(validSchema).valid).toBe(true);
+    expect(validatePrismaSchema(invalidSchema).valid).toBe(false);
+  });
+
+  it('should parse composite primary keys', async () => {
+    const schema = `
+      datasource db {
+        provider = "postgresql"
+        url      = env("DATABASE_URL")
+      }
+
+      model PostTag {
+        postId Int
+        tagId  Int
+        
+        @@id([postId, tagId])
+      }
+    `;
+
+    const result = await parsePrismaSchema(schema);
+    const model = result.models[0];
+
+    expect(model.primaryKey).toBeDefined();
+    expect(model.primaryKey?.fields).toEqual(['postId', 'tagId']);
+  });
+
+  it('should parse indexes and unique constraints', async () => {
+    const schema = `
+      datasource db {
+        provider = "postgresql"
+        url      = env("DATABASE_URL")
+      }
+
+      model User {
+        id        Int      @id
+        email     String
+        firstName String
+        lastName  String
+        
+        @@unique([email])
+        @@index([firstName, lastName])
+      }
+    `;
+
+    const result = await parsePrismaSchema(schema);
+    const model = result.models[0];
+
+    expect(model.uniqueConstraints).toHaveLength(1);
+    expect(model.uniqueConstraints[0].fields).toEqual(['email']);
+    expect(model.indexes).toHaveLength(1);
+    expect(model.indexes[0].fields).toEqual(['firstName', 'lastName']);
+  });
+});