@opensaas/stack-cli 0.4.0 → 0.5.0

package/src/migration/introspectors/prisma-introspector.ts

@@ -0,0 +1,233 @@
+/**
+ * Prisma Schema Introspector
+ *
+ * Parses prisma/schema.prisma and extracts structured information
+ * about models, fields, relationships, and enums.
+ */
+
+import fs from 'fs-extra'
+import path from 'path'
+import type { IntrospectedSchema, IntrospectedModel, IntrospectedField } from '../types.js'
+
+export class PrismaIntrospector {
+  /**
+   * Introspect a Prisma schema file
+   */
+  async introspect(
+    cwd: string,
+    schemaPath: string = 'prisma/schema.prisma',
+  ): Promise<IntrospectedSchema> {
+    const fullPath = path.isAbsolute(schemaPath) ? schemaPath : path.join(cwd, schemaPath)
+
+    if (!(await fs.pathExists(fullPath))) {
+      throw new Error(`Schema file not found: ${fullPath}`)
+    }
+
+    const schema = await fs.readFile(fullPath, 'utf-8')
+
+    return {
+      provider: this.extractProvider(schema),
+      models: this.extractModels(schema),
+      enums: this.extractEnums(schema),
+    }
+  }
+
+  /**
+   * Extract database provider from datasource block
+   */
+  private extractProvider(schema: string): string {
+    const match = schema.match(/datasource\s+\w+\s*\{[^}]*provider\s*=\s*"(\w+)"/)
+    return match ? match[1] : 'unknown'
+  }
+
+  /**
+   * Extract all model definitions
+   */
+  private extractModels(schema: string): IntrospectedModel[] {
+    const models: IntrospectedModel[] = []
+
+    // Match model blocks
+    const modelRegex = /model\s+(\w+)\s*\{([^}]+)\}/g
+    let match
+
+    while ((match = modelRegex.exec(schema)) !== null) {
+      const name = match[1]
+      const body = match[2]
+
+      const fields = this.extractFields(body)
+      const primaryKey = fields.find((f) => f.isId)?.name || 'id'
+
+      models.push({
+        name,
+        fields,
+        hasRelations: fields.some((f) => f.relation !== undefined),
+        primaryKey,
+      })
+    }
+
+    return models
+  }
+
+  /**
+   * Extract fields from a model body
+   */
+  private extractFields(body: string): IntrospectedField[] {
+    const fields: IntrospectedField[] = []
+    const lines = body.split('\n')
+
+    for (const line of lines) {
+      const trimmed = line.trim()
+
+      // Skip empty lines, comments, and model-level attributes
+      if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('@@')) {
+        continue
+      }
+
+      const field = this.parseFieldLine(trimmed)
+      if (field) {
+        fields.push(field)
+      }
+    }
+
+    return fields
+  }
+
+  /**
+   * Parse a single field line
+   */
+  private parseFieldLine(line: string): IntrospectedField | null {
+    // Basic field pattern: name Type modifiers attributes
+    // Examples:
+    //   id        String   @id @default(cuid())
+    //   title     String
+    //   isActive  Boolean? @default(true)
+    //   posts     Post[]
+    //   author    User     @relation(fields: [authorId], references: [id])
+
+    // Remove comments
+    const withoutComment = line.split('//')[0].trim()
+
+    // Match field name and type
+    const fieldMatch = withoutComment.match(/^(\w+)\s+(\w+)(\?)?(\[\])?(.*)$/)
+    if (!fieldMatch) return null
+
+    const [, name, rawType, optional, isList, rest] = fieldMatch
+
+    // Skip if this looks like an index or other non-field line
+    if (['@@', 'index', 'unique'].some((kw) => name.startsWith(kw))) {
+      return null
+    }
+
+    const field: IntrospectedField = {
+      name,
+      type: rawType,
+      isRequired: !optional,
+      isUnique: rest.includes('@unique'),
+      isId: rest.includes('@id'),
+      isList: !!isList,
+    }
+
+    // Extract default value (handle nested parentheses)
+    const defaultMatch = rest.match(/@default\(/)
+    if (defaultMatch) {
+      const startIdx = rest.indexOf('@default(') + '@default('.length
+      let depth = 1
+      let endIdx = startIdx
+
+      while (depth > 0 && endIdx < rest.length) {
+        if (rest[endIdx] === '(') depth++
+        else if (rest[endIdx] === ')') depth--
+        if (depth > 0) endIdx++
+      }
+
+      field.defaultValue = rest.substring(startIdx, endIdx)
+    }
+
+    // Extract relation
+    const relationMatch = rest.match(/@relation\(([^)]+)\)/)
+    if (relationMatch) {
+      const relationBody = relationMatch[1]
+
+      // Parse relation parts
+      const fieldsMatch = relationBody.match(/fields:\s*\[([^\]]+)\]/)
+      const referencesMatch = relationBody.match(/references:\s*\[([^\]]+)\]/)
+      const nameMatch = relationBody.match(/name:\s*"([^"]+)"/) || relationBody.match(/"([^"]+)"/)
+
+      field.relation = {
+        name: nameMatch ? nameMatch[1] : '',
+        model: rawType,
+        fields: fieldsMatch ? fieldsMatch[1].split(',').map((f) => f.trim()) : [],
+        references: referencesMatch ? referencesMatch[1].split(',').map((r) => r.trim()) : [],
+      }
+    }
+
+    return field
+  }
+
+  /**
+   * Extract enum definitions
+   */
+  private extractEnums(schema: string): Array<{ name: string; values: string[] }> {
+    const enums: Array<{ name: string; values: string[] }> = []
+
+    // Match enum blocks
+    const enumRegex = /enum\s+(\w+)\s*\{([^}]+)\}/g
+    let match
+
+    while ((match = enumRegex.exec(schema)) !== null) {
+      const name = match[1]
+      const body = match[2]
+
+      const values = body
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('//'))
+
+      enums.push({ name, values })
+    }
+
+    return enums
+  }
+
+  /**
+   * Map Prisma type to OpenSaaS field type
+   */
+  mapPrismaTypeToOpenSaas(prismaType: string): { type: string; import: string } {
+    const mappings: Record<string, { type: string; import: string }> = {
+      String: { type: 'text', import: 'text' },
+      Int: { type: 'integer', import: 'integer' },
+      Float: { type: 'float', import: 'float' },
+      Boolean: { type: 'checkbox', import: 'checkbox' },
+      DateTime: { type: 'timestamp', import: 'timestamp' },
+      Json: { type: 'json', import: 'json' },
+      BigInt: { type: 'text', import: 'text' }, // No native support
+      Decimal: { type: 'text', import: 'text' }, // No native support
+      Bytes: { type: 'text', import: 'text' }, // No native support
+    }
+
+    return mappings[prismaType] || { type: 'text', import: 'text' }
+  }
+
+  /**
+   * Get warnings for unsupported features
+   */
+  getWarnings(schema: IntrospectedSchema): string[] {
+    const warnings: string[] = []
+
+    // Check for unsupported types
+    for (const model of schema.models) {
+      for (const field of model.fields) {
+        if (['BigInt', 'Decimal', 'Bytes'].includes(field.type)) {
+          warnings.push(
+            `Field "${model.name}.${field.name}" uses unsupported type "${field.type}" - will be mapped to text()`,
+          )
+        }
+      }
+    }
+
+    // Check for composite IDs
+    // This would require checking for @@id in the original schema
+
+    return warnings
+  }
+}

package/src/migration/types.ts

@@ -0,0 +1,92 @@
+/**
+ * Migration types - Shared types for the migration system
+ */
+
+export type ProjectType = 'prisma' | 'nextjs' | 'keystone'
+
+export interface ModelInfo {
+  name: string
+  fieldCount: number
+}
+
+export interface ProjectAnalysis {
+  projectTypes: ProjectType[]
+  cwd: string
+  models?: ModelInfo[]
+  provider?: string
+  hasAuth?: boolean
+  authLibrary?: string
+}
+
+export interface FieldMapping {
+  prismaType: string
+  opensaasType: string
+  opensaasImport: string
+}
+
+export interface MigrationQuestion {
+  id: string
+  text: string
+  type: 'text' | 'select' | 'boolean' | 'multiselect'
+  options?: string[]
+  defaultValue?: string | boolean | string[]
+  required?: boolean
+  dependsOn?: {
+    questionId: string
+    value: string | boolean
+  }
+}
+
+export interface MigrationSession {
+  id: string
+  projectType: ProjectType
+  analysis: ProjectAnalysis
+  currentQuestionIndex: number
+  answers: Record<string, string | boolean | string[]>
+  generatedConfig?: string
+  isComplete: boolean
+  createdAt: Date
+  updatedAt: Date
+}
+
+export interface MigrationOutput {
+  configContent: string
+  dependencies: string[]
+  files: Array<{
+    path: string
+    content: string
+    language: string
+    description: string
+  }>
+  steps: string[]
+  warnings: string[]
+}
+
+export interface IntrospectedModel {
+  name: string
+  fields: IntrospectedField[]
+  hasRelations: boolean
+  primaryKey: string
+}
+
+export interface IntrospectedField {
+  name: string
+  type: string
+  isRequired: boolean
+  isUnique: boolean
+  isId: boolean
+  isList: boolean
+  defaultValue?: string
+  relation?: {
+    name: string
+    model: string
+    fields: string[]
+    references: string[]
+  }
+}
+
+export interface IntrospectedSchema {
+  provider: string
+  models: IntrospectedModel[]
+  enums: Array<{ name: string; values: string[] }>
+}

package/tests/introspectors/keystone-introspector.test.ts

@@ -0,0 +1,255 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { KeystoneIntrospector } from '../../src/migration/introspectors/keystone-introspector.js'
+import fs from 'fs-extra'
+import path from 'path'
+import os from 'os'
+
+describe('KeystoneIntrospector', () => {
+  let introspector: KeystoneIntrospector
+  let tempDir: string
+
+  beforeEach(async () => {
+    introspector = new KeystoneIntrospector()
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'keystone-test-'))
+  })
+
+  afterEach(async () => {
+    await fs.remove(tempDir)
+  })
+
+  it('should load and parse a KeystoneJS config', async () => {
+    const config = `
+export default {
+  db: {
+    provider: 'sqlite',
+    url: 'file:./keystone.db',
+  },
+  lists: {
+    User: {
+      fields: {
+        name: {
+          type: 'text',
+          validation: { isRequired: true },
+        },
+        email: {
+          type: 'text',
+          validation: { isRequired: true },
+        },
+        posts: {
+          type: 'relationship',
+          ref: 'Post.author',
+          many: true,
+        },
+      },
+    },
+    Post: {
+      fields: {
+        title: {
+          type: 'text',
+          validation: { isRequired: true },
+        },
+        author: {
+          type: 'relationship',
+          ref: 'User.posts',
+        },
+      },
+    },
+  },
+}
+`
+    await fs.writeFile(path.join(tempDir, 'keystone.config.js'), config)
+
+    const result = await introspector.introspect(tempDir, 'keystone.config.js')
+
+    expect(result.provider).toBe('sqlite')
+    expect(result.models).toHaveLength(2)
+
+    const user = result.models.find((m) => m.name === 'User')
+    expect(user).toBeDefined()
+    expect(user!.fields).toHaveLength(3)
+
+    const post = result.models.find((m) => m.name === 'Post')
+    expect(post).toBeDefined()
+    expect(post!.hasRelations).toBe(true)
+  })
+
+  it('should map KeystoneJS types to OpenSaaS types', () => {
+    expect(introspector.mapKeystoneTypeToOpenSaas('text')).toEqual({ type: 'text', import: 'text' })
+    expect(introspector.mapKeystoneTypeToOpenSaas('integer')).toEqual({
+      type: 'integer',
+      import: 'integer',
+    })
+    expect(introspector.mapKeystoneTypeToOpenSaas('checkbox')).toEqual({
+      type: 'checkbox',
+      import: 'checkbox',
+    })
+    expect(introspector.mapKeystoneTypeToOpenSaas('timestamp')).toEqual({
+      type: 'timestamp',
+      import: 'timestamp',
+    })
+    expect(introspector.mapKeystoneTypeToOpenSaas('relationship')).toEqual({
+      type: 'relationship',
+      import: 'relationship',
+    })
+  })
+
+  it('should handle file and image fields', () => {
+    expect(introspector.mapKeystoneTypeToOpenSaas('image')).toEqual({
+      type: 'image',
+      import: 'image',
+    })
+    expect(introspector.mapKeystoneTypeToOpenSaas('file')).toEqual({ type: 'file', import: 'file' })
+  })
+
+  it('should handle virtual fields', () => {
+    expect(introspector.mapKeystoneTypeToOpenSaas('virtual')).toEqual({
+      type: 'virtual',
+      import: 'virtual',
+    })
+  })
+
+  it('should generate warnings for migration reminders', async () => {
+    const config = `
+export default {
+  db: {
+    provider: 'postgresql',
+  },
+  lists: {
+    Media: {
+      fields: {
+        image: {
+          type: 'image',
+        },
+        document: {
+          type: 'file',
+        },
+        computed: {
+          type: 'virtual',
+        },
+      },
+    },
+  },
+}
+`
+    await fs.writeFile(path.join(tempDir, 'keystone.config.js'), config)
+
+    const result = await introspector.introspect(tempDir, 'keystone.config.js')
+    const warnings = introspector.getWarnings(result)
+
+    expect(warnings.length).toBeGreaterThan(0)
+    // Should warn about storage configuration (helpful reminder)
+    expect(warnings.some((w) => w.includes('storage'))).toBe(true)
+    // Should remind about manual migration for virtual field hooks
+    expect(warnings.some((w) => w.includes('virtual') && w.includes('manually migrate'))).toBe(true)
+  })
+
+  it('should throw for missing config', async () => {
+    await expect(introspector.introspect(tempDir, 'nonexistent.ts')).rejects.toThrow(
+      'KeystoneJS config not found',
+    )
+  })
+
+  it('should try alternative config paths', async () => {
+    const config = `
+export default {
+  db: {
+    provider: 'sqlite',
+  },
+  lists: {
+    User: {
+      fields: {
+        name: {
+          type: 'text',
+        },
+      },
+    },
+  },
+}
+`
+    // Create config at alternative path
+    await fs.writeFile(path.join(tempDir, 'keystone.ts'), config)
+
+    // Should find it even if we specify the default path
+    const result = await introspector.introspect(tempDir)
+
+    expect(result.models).toHaveLength(1)
+    expect(result.models[0].name).toBe('User')
+  })
+
+  it('should parse relationship fields correctly', async () => {
+    const config = `
+export default {
+  db: {
+    provider: 'sqlite',
+  },
+  lists: {
+    Post: {
+      fields: {
+        author: {
+          type: 'relationship',
+          ref: 'User.posts',
+        },
+      },
+    },
+    User: {
+      fields: {
+        posts: {
+          type: 'relationship',
+          ref: 'Post.author',
+          many: true,
+        },
+      },
+    },
+  },
+}
+`
+    await fs.writeFile(path.join(tempDir, 'keystone.config.js'), config)
+
+    const result = await introspector.introspect(tempDir, 'keystone.config.js')
+
+    const post = result.models.find((m) => m.name === 'Post')
+    const authorField = post!.fields.find((f) => f.name === 'author')
+    expect(authorField!.relation).toBeDefined()
+    expect(authorField!.relation!.model).toBe('User')
+    expect(authorField!.relation!.references).toEqual(['posts'])
+
+    const user = result.models.find((m) => m.name === 'User')
+    const postsField = user!.fields.find((f) => f.name === 'posts')
+    expect(postsField!.isList).toBe(true)
+  })
+
+  it('should handle field validation options', async () => {
+    const config = `
+export default {
+  db: {
+    provider: 'sqlite',
+  },
+  lists: {
+    User: {
+      fields: {
+        email: {
+          type: 'text',
+          validation: { isRequired: true },
+          isRequired: true,
+        },
+        age: {
+          type: 'integer',
+          defaultValue: 0,
+        },
+      },
+    },
+  },
+}
+`
+    await fs.writeFile(path.join(tempDir, 'keystone.config.js'), config)
+
+    const result = await introspector.introspect(tempDir, 'keystone.config.js')
+    const user = result.models[0]
+
+    const emailField = user.fields.find((f) => f.name === 'email')
+    expect(emailField!.isRequired).toBe(true)
+
+    const ageField = user.fields.find((f) => f.name === 'age')
+    expect(ageField!.defaultValue).toBe('0')
+  })
+})