@opensaas/stack-cli 0.1.0

package/src/commands/init.ts

@@ -0,0 +1,367 @@
+import * as path from 'path'
+import * as fs from 'fs'
+import chalk from 'chalk'
+import ora from 'ora'
+import prompts from 'prompts'
+
+export async function initCommand(projectName: string | undefined) {
+  console.log(chalk.bold.cyan('\n🚀 Create OpenSaas Project\n'))
+
+  // Prompt for project name if not provided
+  if (!projectName) {
+    const response = await prompts({
+      type: 'text',
+      name: 'name',
+      message: 'Project name:',
+      initial: 'my-opensaas-app',
+      validate: (value) => {
+        if (!value) return 'Project name is required'
+        if (!/^[a-z0-9-]+$/.test(value)) {
+          return 'Project name must contain only lowercase letters, numbers, and hyphens'
+        }
+        return true
+      },
+    })
+
+    if (!response.name) {
+      console.log(chalk.yellow('\n❌ Cancelled'))
+      process.exit(0)
+    }
+
+    projectName = response.name
+  }
+
+  // Type guard to ensure projectName is defined
+  if (!projectName) {
+    console.error(chalk.red('\n❌ Project name is required'))
+    process.exit(1)
+  }
+
+  const projectPath = path.join(process.cwd(), projectName)
+
+  // Check if directory already exists
+  if (fs.existsSync(projectPath)) {
+    console.error(chalk.red(`\n❌ Directory "${projectName}" already exists`))
+    process.exit(1)
+  }
+
+  const spinner = ora('Creating project structure...').start()
+
+  try {
+    // Create project directory
+    fs.mkdirSync(projectPath, { recursive: true })
+
+    // Create basic structure
+    fs.mkdirSync(path.join(projectPath, 'app'), { recursive: true })
+    fs.mkdirSync(path.join(projectPath, 'lib'), { recursive: true })
+    fs.mkdirSync(path.join(projectPath, 'prisma'), { recursive: true })
+
+    spinner.text = 'Writing configuration files...'
+
+    // Create package.json
+    const packageJson = {
+      name: projectName,
+      version: '0.1.0',
+      private: true,
+      scripts: {
+        dev: 'next dev',
+        build: 'next build',
+        start: 'next start',
+        generate: 'opensaas generate',
+        'db:push': 'prisma db push',
+        'db:studio': 'prisma studio',
+      },
+      dependencies: {
+        '@opensaas/stack-core': '^0.1.0',
+        '@prisma/client': '^5.7.1',
+        next: '^14.0.4',
+        react: '^18.2.0',
+        'react-dom': '^18.2.0',
+      },
+      devDependencies: {
+        '@opensaas/stack-cli': '^0.1.0',
+        '@types/node': '^20.10.0',
+        '@types/react': '^18.2.45',
+        '@types/react-dom': '^18.2.18',
+        prisma: '^5.7.1',
+        tsx: '^4.7.0',
+        typescript: '^5.3.3',
+      },
+    }
+
+    fs.writeFileSync(path.join(projectPath, 'package.json'), JSON.stringify(packageJson, null, 2))
+
+    // Create tsconfig.json
+    const tsConfig = {
+      compilerOptions: {
+        target: 'ES2022',
+        lib: ['dom', 'dom.iterable', 'esnext'],
+        allowJs: true,
+        skipLibCheck: true,
+        strict: true,
+        noEmit: true,
+        esModuleInterop: true,
+        module: 'esnext',
+        moduleResolution: 'bundler',
+        resolveJsonModule: true,
+        isolatedModules: true,
+        jsx: 'preserve',
+        incremental: true,
+        plugins: [{ name: 'next' }],
+        paths: {
+          '@/*': ['./*'],
+        },
+      },
+      include: ['next-env.d.ts', '**/*.ts', '**/*.tsx', '.next/types/**/*.ts'],
+      exclude: ['node_modules'],
+    }
+
+    fs.writeFileSync(path.join(projectPath, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2))
+
+    // Create next.config.js
+    const nextConfig = `/** @type {import('next').NextConfig} */
+const nextConfig = {
+  experimental: {
+    serverComponentsExternalPackages: ['@prisma/client', '@opensaas/stack-core'],
+  },
+}
+
+module.exports = nextConfig
+`
+    fs.writeFileSync(path.join(projectPath, 'next.config.js'), nextConfig)
+
+    // Create .env
+    const env = `DATABASE_URL="file:./dev.db"
+`
+    fs.writeFileSync(path.join(projectPath, '.env'), env)
+
+    // Create .gitignore
+    const gitignore = `# Dependencies
+node_modules
+.pnp
+.pnp.js
+
+# Testing
+coverage
+
+# Next.js
+.next
+out
+
+# Production
+build
+dist
+
+# Misc
+.DS_Store
+*.pem
+
+# Debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Local env files
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Vercel
+.vercel
+
+# TypeScript
+*.tsbuildinfo
+
+# OpenSaas generated
+.opensaas
+
+# Prisma
+prisma/dev.db
+prisma/dev.db-journal
+`
+    fs.writeFileSync(path.join(projectPath, '.gitignore'), gitignore)
+
+    // Create opensaas.config.ts
+    const config = `import { config, list } from '@opensaas/stack-core'
+import { text, relationship, password } from '@opensaas/stack-core/fields'
+import type { AccessControl } from '@opensaas/stack-core'
+
+// Access control helpers
+const isSignedIn: AccessControl = ({ session }) => {
+  return !!session
+}
+
+export default config({
+  db: {
+    provider: 'sqlite',
+    url: process.env.DATABASE_URL || 'file:./dev.db',
+  },
+
+  lists: {
+    User: list({
+      fields: {
+        name: text({ validation: { isRequired: true } }),
+        email: text({
+          validation: { isRequired: true },
+          isIndexed: 'unique',
+        }),
+        password: password({ validation: { isRequired: true } }),
+      },
+    }),
+  },
+
+  session: {
+    getSession: async () => {
+      // TODO: Integrate with your auth system
+      return null
+    }
+  },
+
+  ui: {
+    basePath: '/admin',
+  }
+})
+`
+    fs.writeFileSync(path.join(projectPath, 'opensaas.config.ts'), config)
+
+    // Create lib/context.ts
+    const contextFile = `import { PrismaClient } from '@prisma/client'
+import { getContext as createContext } from '@opensaas/stack-core'
+import config from '../opensaas.config'
+import type { Context } from '../.opensaas/types'
+
+// Singleton Prisma client
+const globalForPrisma = globalThis as unknown as {
+  prisma: PrismaClient | undefined
+}
+
+export const prisma = globalForPrisma.prisma ?? new PrismaClient()
+
+if (process.env.NODE_ENV !== 'production') {
+  globalForPrisma.prisma = prisma
+}
+
+/**
+ * Get an access-controlled context for the current session
+ */
+export async function getContext(): Promise<Context> {
+  const session = config.session ? await config.session.getSession() : null
+  const context = await createContext<PrismaClient>(config, prisma, session)
+  return context as Context
+}
+`
+    fs.writeFileSync(path.join(projectPath, 'lib', 'context.ts'), contextFile)
+
+    // Create app/page.tsx
+    const page = `export default function Home() {
+  return (
+    <main className="flex min-h-screen flex-col items-center justify-center p-24">
+      <h1 className="text-4xl font-bold mb-4">Welcome to OpenSaas</h1>
+      <p className="text-gray-600">Your project is ready to go!</p>
+
+      <div className="mt-8 space-y-2">
+        <p className="text-sm">Next steps:</p>
+        <ol className="text-sm text-gray-600 list-decimal list-inside space-y-1">
+          <li>Run <code className="bg-gray-100 px-2 py-1 rounded">npm run generate</code></li>
+          <li>Run <code className="bg-gray-100 px-2 py-1 rounded">npm run db:push</code></li>
+          <li>Edit <code className="bg-gray-100 px-2 py-1 rounded">opensaas.config.ts</code> to define your schema</li>
+        </ol>
+      </div>
+    </main>
+  )
+}
+`
+    fs.writeFileSync(path.join(projectPath, 'app', 'page.tsx'), page)
+
+    // Create app/layout.tsx
+    const layout = `export const metadata = {
+  title: '${projectName}',
+  description: 'Built with OpenSaas',
+}
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode
+}) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  )
+}
+`
+    fs.writeFileSync(path.join(projectPath, 'app', 'layout.tsx'), layout)
+
+    // Create README.md
+    const readme = `# ${projectName}
+
+Built with [OpenSaas Stack](https://github.com/your-org/opensaas-stack)
+
+## Getting Started
+
+1. Install dependencies:
+   \`\`\`bash
+   npm install
+   # or
+   pnpm install
+   \`\`\`
+
+2. Generate Prisma schema and types:
+   \`\`\`bash
+   npm run generate
+   \`\`\`
+
+3. Push schema to database:
+   \`\`\`bash
+   npm run db:push
+   \`\`\`
+
+4. Run the development server:
+   \`\`\`bash
+   npm run dev
+   \`\`\`
+
+Open [http://localhost:3000](http://localhost:3000) to see your app.
+
+## Project Structure
+
+- \`opensaas.config.ts\` - Your schema definition with access control
+- \`lib/context.ts\` - Database context with access control
+- \`app/\` - Next.js app router pages
+- \`prisma/\` - Generated Prisma schema
+- \`.opensaas/\` - Generated TypeScript types
+
+## Learn More
+
+- [OpenSaas Documentation](https://github.com/your-org/opensaas-stack)
+- [Next.js Documentation](https://nextjs.org/docs)
+- [Prisma Documentation](https://www.prisma.io/docs)
+`
+    fs.writeFileSync(path.join(projectPath, 'README.md'), readme)
+
+    spinner.succeed(chalk.green('Project created successfully!'))
+
+    console.log(chalk.bold.green(`\n✨ Created ${projectName}\n`))
+    console.log(chalk.gray('Next steps:\n'))
+    console.log(chalk.cyan(`  cd ${projectName}`))
+    console.log(chalk.cyan('  npm install'))
+    console.log(chalk.cyan('  npm run generate'))
+    console.log(chalk.cyan('  npm run db:push'))
+    console.log(chalk.cyan('  npm run dev'))
+    console.log()
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } catch (error: any) {
+    spinner.fail(chalk.red('Failed to create project'))
+    console.error(chalk.red('\n❌ Error:'), error.message)
+
+    // Cleanup on failure
+    if (fs.existsSync(projectPath)) {
+      fs.rmSync(projectPath, { recursive: true, force: true })
+    }
+
+    process.exit(1)
+  }
+}

package/src/generator/context.ts

@@ -0,0 +1,75 @@
+import type { OpenSaasConfig } from '@opensaas/stack-core'
+import * as fs from 'fs'
+import * as path from 'path'
+
+/**
+ * Generate context factory that abstracts Prisma client from developers
+ *
+ * Creates a simple API with getContext() and getContextWithSession(session)
+ * that internally handles Prisma singleton and config imports.
+ */
+export function generateContext(config: OpenSaasConfig): string {
+  // Check if custom Prisma client constructor is provided
+  const hasCustomConstructor = !!config.db.prismaClientConstructor
+
+  // Generate the Prisma client instantiation code
+  const prismaInstantiation = hasCustomConstructor
+    ? `config.db.prismaClientConstructor!(PrismaClient)`
+    : `new PrismaClient()`
+
+  return `/**
+ * Auto-generated context factory
+ *
+ * This module provides a simple API for creating OpenSaas contexts.
+ * It abstracts away Prisma client management and configuration.
+ *
+ * DO NOT EDIT - This file is automatically generated by 'pnpm generate'
+ */
+
+import { getContext as getOpensaasContext } from '@opensaas/stack-core'
+import { PrismaClient } from './prisma-client'
+import config from '../opensaas.config'
+
+// Internal Prisma singleton - managed automatically
+const globalForPrisma = globalThis as unknown as { prisma: PrismaClient | undefined }
+const prisma = globalForPrisma.prisma ?? ${prismaInstantiation}
+if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma
+
+/**
+ * Get OpenSaas context with optional session
+ *
+ * @param session - Optional session object (structure defined by your application)
+ *
+ * @example
+ * \`\`\`typescript
+ * // Anonymous access
+ * const context = getContext()
+ * const posts = await context.db.post.findMany()
+ *
+ * // Authenticated access
+ * const context = getContext({ userId: 'user-123' })
+ * const myPosts = await context.db.post.findMany()
+ * \`\`\`
+ */
+export function getContext(session?: { userId?: string; [key: string]: unknown } | null) {
+  return getOpensaasContext(config, prisma, session ?? null)
+}
+
+export const rawOpensaasContext = getContext()
+`
+}
+
+/**
+ * Write context factory to file
+ */
+export function writeContext(config: OpenSaasConfig, outputPath: string): void {
+  const content = generateContext(config)
+
+  // Ensure directory exists
+  const dir = path.dirname(outputPath)
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true })
+  }
+
+  fs.writeFileSync(outputPath, content, 'utf-8')
+}

package/src/generator/index.ts

@@ -0,0 +1,4 @@
+export { generatePrismaSchema, writePrismaSchema } from './prisma.js'
+export { generateTypes, writeTypes } from './types.js'
+export { patchPrismaTypes } from './type-patcher.js'
+export { generateContext, writeContext } from './context.js'

package/src/generator/prisma.ts

@@ -0,0 +1,157 @@
+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-js"')
+  lines.push(`  output   = "../${opensaasPath}/prisma-client"`)
+  lines.push('}')
+  lines.push('')
+  lines.push('datasource db {')
+  lines.push(`  provider = "${config.db.provider}"`)
+  lines.push('  url      = env("DATABASE_URL")')
+  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)) {
+      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/type-patcher.ts

@@ -0,0 +1,93 @@
+import type { OpenSaasConfig } from '@opensaas/stack-core'
+import * as fs from 'fs'
+import * as path from 'path'
+
+/**
+ * Patches Prisma's generated types based on field-level type patch configurations
+ *
+ * This reads Prisma's generated index.d.ts and replaces field types according to
+ * the `typePatch` configuration on each field. Fields can specify custom result types
+ * that will replace the original Prisma types in query results.
+ *
+ * The patched types are written to `.opensaas/prisma-client.d.ts` so users can
+ * import from there to get the transformed types.
+ */
+export function patchPrismaTypes(config: OpenSaasConfig, projectRoot: string): void {
+  const opensaasPath = config.opensaasPath || '.opensaas'
+
+  // Prisma generates to opensaasPath/prisma-client
+  const prismaClientDir = path.join(projectRoot, opensaasPath, 'prisma-client')
+  const prismaIndexPath = path.join(prismaClientDir, 'index.d.ts')
+
+  // Check if Prisma types exist
+  if (!fs.existsSync(prismaIndexPath)) {
+    console.warn(
+      '⚠️  Prisma types not found. Run `npx prisma generate` first to generate Prisma Client.',
+    )
+    return
+  }
+
+  // Read original Prisma types
+  const originalTypes = fs.readFileSync(prismaIndexPath, 'utf-8')
+
+  // Collect all fields that need type patching
+  type FieldPatch = {
+    fieldName: string
+    resultType: string
+    patchScope: 'scalars-only' | 'all'
+  }
+
+  const fieldPatches: FieldPatch[] = []
+
+  for (const listConfig of Object.values(config.lists)) {
+    for (const [fieldName, fieldConfig] of Object.entries(listConfig.fields)) {
+      if (fieldConfig.typePatch) {
+        fieldPatches.push({
+          fieldName,
+          resultType: fieldConfig.typePatch.resultType,
+          patchScope: fieldConfig.typePatch.patchScope || 'scalars-only',
+        })
+      }
+    }
+  }
+
+  if (fieldPatches.length === 0) {
+    // No fields need patching
+    return
+  }
+
+  // Patch the types
+  let patchedTypes = originalTypes
+
+  // For each field that needs patching, replace its type
+  for (const { fieldName, resultType, patchScope } of fieldPatches) {
+    if (patchScope === 'scalars-only') {
+      // Pattern matches: fieldName: <type> ONLY inside scalars: $Extensions.GetPayloadResult<{...}>
+      // This ensures we don't patch Input types (UserCreateInput, etc.)
+      // Example match:
+      // scalars: $Extensions.GetPayloadResult<{
+      //   id: string
+      //   password: string  ← Replace this
+      //   ...
+      const pattern = new RegExp(
+        `(scalars:\\s*\\$Extensions\\.GetPayloadResult<\\{[^}]*?\\b${fieldName}:\\s*)[^,\\n}]+`,
+        'g',
+      )
+
+      patchedTypes = patchedTypes.replace(pattern, `$1${resultType}`)
+    } else {
+      // patchScope === 'all' - patch everywhere the field appears
+      // This is more aggressive and will patch input types too
+      const pattern = new RegExp(`(\\b${fieldName}:\\s*)[^,\\n}]+`, 'g')
+      patchedTypes = patchedTypes.replace(pattern, `$1${resultType}`)
+    }
+  }
+
+  // Write patched types back to Prisma's index.d.ts
+  // This directly modifies the Prisma-generated file with our type patches
+  fs.writeFileSync(prismaIndexPath, patchedTypes, 'utf-8')
+
+  console.log(
+    `✅ Patched Prisma types (${fieldPatches.length} field${fieldPatches.length === 1 ? '' : 's'})`,
+  )
+}