@opensaas/stack-cli 0.5.0 → 0.6.1

package/src/generator/prisma.ts

@@ -1,161 +0,0 @@
-import type { OpenSaasConfig, FieldConfig, RelationshipField } from '@opensaas/stack-core'
-import * as fs from 'fs'
-import * as path from 'path'
-
-/**
- * Map OpenSaas field types to Prisma field types
- */
-function mapFieldTypeToPrisma(fieldName: string, field: FieldConfig): string | null {
-  // Relationships are handled separately
-  if (field.type === 'relationship') {
-    return null
-  }
-
-  // Use field's own Prisma type generator if available
-  if (field.getPrismaType) {
-    const result = field.getPrismaType(fieldName)
-    return result.type
-  }
-
-  // Fallback for fields without generator methods
-  throw new Error(`Field type "${field.type}" does not implement getPrismaType method`)
-}
-
-/**
- * Get field modifiers (?, @default, @unique, etc.)
- */
-function getFieldModifiers(fieldName: string, field: FieldConfig): string {
-  // Handle relationships separately
-  if (field.type === 'relationship') {
-    const relField = field as RelationshipField
-    if (relField.many) {
-      return '[]'
-    } else {
-      return '?'
-    }
-  }
-
-  // Use field's own Prisma type generator if available
-  if (field.getPrismaType) {
-    const result = field.getPrismaType(fieldName)
-    return result.modifiers || ''
-  }
-
-  // Fallback for fields without generator methods
-  return ''
-}
-
-/**
- * Parse relationship ref to get target list and field
- */
-function parseRelationshipRef(ref: string): { list: string; field: string } {
-  const [list, field] = ref.split('.')
-  if (!list || !field) {
-    throw new Error(`Invalid relationship ref: ${ref}`)
-  }
-  return { list, field }
-}
-
-/**
- * Generate Prisma schema from OpenSaas config
- */
-export function generatePrismaSchema(config: OpenSaasConfig): string {
-  const lines: string[] = []
-
-  const opensaasPath = config.opensaasPath || '.opensaas'
-
-  // Generator and datasource
-  lines.push('generator client {')
-  lines.push('  provider = "prisma-client"')
-  lines.push(`  output   = "../${opensaasPath}/prisma-client"`)
-  lines.push('}')
-  lines.push('')
-  lines.push('datasource db {')
-  lines.push(`  provider = "${config.db.provider}"`)
-  lines.push('}')
-  lines.push('')
-
-  // Generate models for each list
-  for (const [listName, listConfig] of Object.entries(config.lists)) {
-    lines.push(`model ${listName} {`)
-
-    // Always add id field
-    lines.push('  id        String   @id @default(cuid())')
-
-    // Track relationship fields for later processing
-    const relationshipFields: Array<{
-      name: string
-      field: RelationshipField
-    }> = []
-
-    // Add regular fields
-    for (const [fieldName, fieldConfig] of Object.entries(listConfig.fields)) {
-      // Skip virtual fields - they don't create database columns
-      if (fieldConfig.virtual) {
-        continue
-      }
-
-      if (fieldConfig.type === 'relationship') {
-        relationshipFields.push({
-          name: fieldName,
-          field: fieldConfig as RelationshipField,
-        })
-        continue
-      }
-
-      const prismaType = mapFieldTypeToPrisma(fieldName, fieldConfig)
-      if (!prismaType) continue // Skip if no type returned
-
-      const modifiers = getFieldModifiers(fieldName, fieldConfig)
-
-      // Format with proper spacing
-      const paddedName = fieldName.padEnd(12)
-      lines.push(`  ${paddedName} ${prismaType}${modifiers}`)
-    }
-
-    // Add relationship fields
-    for (const { name: fieldName, field: relField } of relationshipFields) {
-      const { list: targetList } = parseRelationshipRef(relField.ref)
-      const _modifiers = getFieldModifiers(fieldName, relField)
-      const paddedName = fieldName.padEnd(12)
-
-      if (relField.many) {
-        // One-to-many relationship
-        lines.push(`  ${paddedName} ${targetList}[]`)
-      } else {
-        // Many-to-one relationship (add foreign key field)
-        const foreignKeyField = `${fieldName}Id`
-        const fkPaddedName = foreignKeyField.padEnd(12)
-
-        lines.push(`  ${fkPaddedName} String?`)
-        lines.push(
-          `  ${paddedName} ${targetList}?  @relation(fields: [${foreignKeyField}], references: [id])`,
-        )
-      }
-    }
-
-    // Always add timestamps
-    lines.push('  createdAt DateTime @default(now())')
-    lines.push('  updatedAt DateTime @updatedAt')
-
-    lines.push('}')
-    lines.push('')
-  }
-
-  return lines.join('\n')
-}
-
-/**
- * Write Prisma schema to file
- */
-export function writePrismaSchema(config: OpenSaasConfig, outputPath: string): void {
-  const schema = generatePrismaSchema(config)
-
-  // Ensure directory exists
-  const dir = path.dirname(outputPath)
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true })
-  }
-
-  fs.writeFileSync(outputPath, schema, 'utf-8')
-}

package/src/generator/types.test.ts

@@ -1,268 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { generateTypes } from './types.js'
-import type { OpenSaasConfig } from '@opensaas/stack-core'
-import { text, integer, relationship, checkbox } from '@opensaas/stack-core/fields'
-
-describe('Types Generator', () => {
-  describe('generateTypes', () => {
-    it('should generate type definitions for basic model', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-        },
-        lists: {
-          User: {
-            fields: {
-              name: text({ validation: { isRequired: true } }),
-              email: text({ validation: { isRequired: true } }),
-            },
-          },
-        },
-      }
-
-      const types = generateTypes(config)
-
-      expect(types).toMatchSnapshot()
-    })
-
-    it('should generate CreateInput type', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-        },
-        lists: {
-          Post: {
-            fields: {
-              title: text({ validation: { isRequired: true } }),
-              content: text(),
-            },
-          },
-        },
-      }
-
-      const types = generateTypes(config)
-
-      expect(types).toMatchSnapshot()
-    })
-
-    it('should generate UpdateInput type', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-        },
-        lists: {
-          Post: {
-            fields: {
-              title: text({ validation: { isRequired: true } }),
-              content: text(),
-            },
-          },
-        },
-      }
-
-      const types = generateTypes(config)
-
-      expect(types).toMatchSnapshot()
-    })
-
-    it('should generate WhereInput type', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-        },
-        lists: {
-          User: {
-            fields: {
-              name: text(),
-            },
-          },
-        },
-      }
-
-      const types = generateTypes(config)
-
-      expect(types).toMatchSnapshot()
-    })
-
-    it('should generate Context type with all operations', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-        },
-        lists: {
-          User: {
-            fields: {
-              name: text(),
-            },
-          },
-        },
-      }
-
-      const types = generateTypes(config)
-
-      expect(types).toMatchSnapshot()
-    })
-
-    it('should handle relationship fields in types', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-        },
-        lists: {
-          User: {
-            fields: {
-              name: text(),
-              posts: relationship({ ref: 'Post.author', many: true }),
-            },
-          },
-          Post: {
-            fields: {
-              title: text(),
-              author: relationship({ ref: 'User.posts' }),
-            },
-          },
-        },
-      }
-
-      const types = generateTypes(config)
-
-      expect(types).toMatchSnapshot()
-    })
-
-    it('should handle relationship fields in CreateInput', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-        },
-        lists: {
-          Post: {
-            fields: {
-              title: text(),
-              author: relationship({ ref: 'User.posts' }),
-            },
-          },
-          User: {
-            fields: {
-              name: text(),
-            },
-          },
-        },
-      }
-
-      const types = generateTypes(config)
-
-      expect(types).toMatchSnapshot()
-    })
-
-    it('should handle relationship fields in UpdateInput', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-        },
-        lists: {
-          Post: {
-            fields: {
-              title: text(),
-              author: relationship({ ref: 'User.posts' }),
-            },
-          },
-          User: {
-            fields: {
-              name: text(),
-            },
-          },
-        },
-      }
-
-      const types = generateTypes(config)
-
-      expect(types).toMatchSnapshot()
-    })
-
-    it('should generate types for multiple lists', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-        },
-        lists: {
-          User: {
-            fields: {
-              name: text(),
-            },
-          },
-          Post: {
-            fields: {
-              title: text(),
-            },
-          },
-          Comment: {
-            fields: {
-              content: text(),
-            },
-          },
-        },
-      }
-
-      const types = generateTypes(config)
-
-      expect(types).toMatchSnapshot()
-    })
-
-    it('should handle integer fields correctly', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-        },
-        lists: {
-          Product: {
-            fields: {
-              name: text(),
-              price: integer(),
-            },
-          },
-        },
-      }
-
-      const types = generateTypes(config)
-
-      expect(types).toContain('price:')
-      expect(types).toContain('number')
-    })
-
-    it('should handle checkbox fields correctly', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-        },
-        lists: {
-          Post: {
-            fields: {
-              title: text(),
-              isPublished: checkbox(),
-            },
-          },
-        },
-      }
-
-      const types = generateTypes(config)
-
-      expect(types).toContain('isPublished:')
-      expect(types).toContain('boolean')
-    })
-
-    it('should include header comment', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-        },
-        lists: {},
-      }
-
-      const types = generateTypes(config)
-
-      expect(types).toContain('/**')
-      expect(types).toContain('Generated types from OpenSaas configuration')
-      expect(types).toContain('DO NOT EDIT')
-    })
-  })
-})