@opensaas/stack-cli 0.3.0 → 0.5.0

package/src/generator/context.test.ts

@@ -60,7 +60,9 @@ describe('Context Generator', () => {
       const context = generateContext(config)
 
       expect(context).toContain('const globalForPrisma')
-      expect(context).toContain('globalThis as unknown as { prisma: PrismaClient | null }')
+      expect(context).toContain(
+        'globalThis as unknown as { prisma: ReturnType<typeof createExtendedPrisma> | null }',
+      )
       expect(context).toContain('globalForPrisma.prisma')
       expect(context).toContain("if (process.env.NODE_ENV !== 'production')")
     })

package/src/generator/context.ts

@@ -123,6 +123,7 @@ import { getContext as getOpensaasContext } from '@opensaas/stack-core'
 import type { Session as OpensaasSession, OpenSaasConfig } from '@opensaas/stack-core'
 import { PrismaClient } from './prisma-client/client'
 import type { Context } from './types'
+import { prismaExtensions } from './prisma-extensions'
 import configOrPromise from '../opensaas.config'
 
 // Resolve config if it's a Promise (when plugins are present)
@@ -130,15 +131,29 @@ const configPromise = Promise.resolve(configOrPromise)
 let resolvedConfig: OpenSaasConfig | null = null
 
 // Internal Prisma singleton - managed automatically
-const globalForPrisma = globalThis as unknown as { prisma: PrismaClient | null }
-let prisma: PrismaClient | null = null
+const globalForPrisma = globalThis as unknown as { prisma: ReturnType<typeof createExtendedPrisma> | null }
+let prisma: ReturnType<typeof createExtendedPrisma> | null = null
+
+/**
+ * Create Prisma client with result extensions
+ */
+function createExtendedPrisma(basePrisma: PrismaClient) {
+  // Check if there are any extensions to apply
+  if (Object.keys(prismaExtensions).length === 0) {
+    return basePrisma
+  }
+  // Apply result extensions
+  return basePrisma.$extends(prismaExtensions)
+}
 
 async function getPrisma() {
   if (!prisma) {
     if (!resolvedConfig) {
       resolvedConfig = await configPromise
     }
-    prisma = globalForPrisma.prisma ?? ${prismaInstantiation}
+    const basePrisma = ${prismaInstantiation}
+    const extendedPrisma = createExtendedPrisma(basePrisma)
+    prisma = globalForPrisma.prisma ?? extendedPrisma
     if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma
   }
   return prisma
@@ -175,7 +190,7 @@ ${storageUtilities}
 export async function getContext<TSession extends OpensaasSession = OpensaasSession>(session?: TSession): Promise<Context<TSession>> {
   const config = await getConfig()
   const prismaClient = await getPrisma()
-  return getOpensaasContext(config, prismaClient, session ?? null, storage) as Context<TSession>
+  return getOpensaasContext(config, prismaClient, session ?? null, storage) as unknown as Context<TSession>
 }
 
 /**
@@ -185,7 +200,7 @@ export async function getContext<TSession extends OpensaasSession = OpensaasSess
 export const rawOpensaasContext = (async () => {
   const config = await getConfig()
   const prismaClient = await getPrisma()
-  return getOpensaasContext(config, prismaClient, null, storage)
+  return getOpensaasContext(config, prismaClient, null, storage) as unknown as Context
 })()
 
 /**

package/src/generator/index.ts

@@ -2,6 +2,6 @@ export { generatePrismaSchema, writePrismaSchema } from './prisma.js'
 export { generatePrismaConfig, writePrismaConfig } from './prisma-config.js'
 export { generateTypes, writeTypes } from './types.js'
 export { generateListsNamespace, writeLists } from './lists.js'
-export { patchPrismaTypes } from './type-patcher.js'
 export { generateContext, writeContext } from './context.js'
 export { generatePluginTypes, writePluginTypes } from './plugin-types.js'
+export { generatePrismaExtensions, writePrismaExtensions } from './prisma-extensions.js'

package/src/generator/lists.ts

@@ -2,6 +2,25 @@ import type { OpenSaasConfig } from '@opensaas/stack-core'
 import * as fs from 'fs'
 import * as path from 'path'
 
+/**
+ * Map field type string to TypeScript field type name
+ */
+function getFieldTypeName(fieldType: string): string {
+  const typeMap: Record<string, string> = {
+    text: 'TextField',
+    integer: 'IntegerField',
+    checkbox: 'CheckboxField',
+    timestamp: 'TimestampField',
+    password: 'PasswordField',
+    select: 'SelectField',
+    relationship: 'RelationshipField',
+    json: 'JsonField',
+    virtual: 'VirtualField',
+  }
+
+  return typeMap[fieldType] || 'BaseFieldConfig'
+}
+
 /**
  * Generate Lists namespace with TypeInfo for each list
  * This provides strongly-typed hooks with Prisma input types
@@ -61,15 +80,34 @@ export function generateListsNamespace(config: OpenSaasConfig): string {
   lines.push('export declare namespace Lists {')
 
   // Generate type for each list
-  for (const listName of Object.keys(config.lists)) {
+  for (const [listName, listConfig] of Object.entries(config.lists)) {
     lines.push(
       `  export type ${listName} = import('@opensaas/stack-core').ListConfig<Lists.${listName}.TypeInfo>`,
     )
     lines.push('')
     lines.push(`  namespace ${listName} {`)
     lines.push(`    export type Item = import('./types').${listName}`)
+    lines.push('')
+
+    // Generate Fields type
+    lines.push(`    /**`)
+    lines.push(`     * Field configurations for ${listName}`)
+    lines.push(`     * Maps field names to their field config types`)
+    lines.push(`     */`)
+    lines.push(`    export type Fields = {`)
+    for (const [fieldName, fieldConfig] of Object.entries(listConfig.fields)) {
+      const fieldTypeName = getFieldTypeName(fieldConfig.type)
+      lines.push(
+        `      ${fieldName}: import('@opensaas/stack-core').${fieldTypeName}<Lists.${listName}.TypeInfo>`,
+      )
+    }
+    lines.push(`    }`)
+    lines.push('')
+
+    // Generate TypeInfo with fields property
     lines.push(`    export type TypeInfo = {`)
     lines.push(`      key: '${listName}'`)
+    lines.push(`      fields: Fields`)
     lines.push(`      item: Item`)
     lines.push(`      inputs: {`)
     lines.push(`        create: import('./prisma-client/client').Prisma.${listName}CreateInput`)

package/src/generator/prisma-extensions.ts

@@ -0,0 +1,159 @@
+import type { OpenSaasConfig, FieldConfig } from '@opensaas/stack-core'
+import * as fs from 'fs'
+import * as path from 'path'
+
+/**
+ * Generate Prisma result extensions configuration
+ * This creates a Prisma client extension that calls field resolveOutput hooks
+ */
+export function generatePrismaExtensions(config: OpenSaasConfig): string {
+  const lines: string[] = []
+
+  // Add header comment
+  lines.push('/**')
+  lines.push(' * Generated Prisma result extensions from OpenSaas configuration')
+  lines.push(' * DO NOT EDIT - This file is automatically generated')
+  lines.push(' */')
+  lines.push('')
+
+  // Add imports
+  lines.push("import { Prisma } from './prisma-client/client'")
+  lines.push("import configOrPromise from '../opensaas.config'")
+  lines.push('')
+
+  // Resolve config synchronously if possible (will be resolved by context.ts anyway)
+  lines.push('// Resolve config - may be a promise if plugins are present')
+  lines.push('let resolvedConfig: any = null')
+  lines.push('const configPromise = Promise.resolve(configOrPromise)')
+  lines.push('configPromise.then(cfg => { resolvedConfig = cfg })')
+  lines.push('')
+
+  // Check if any fields have result extensions or are virtual
+  let hasExtensions = false
+  for (const listConfig of Object.values(config.lists)) {
+    for (const fieldConfig of Object.values(listConfig.fields)) {
+      if (fieldConfig.resultExtension || fieldConfig.virtual) {
+        hasExtensions = true
+        break
+      }
+    }
+    if (hasExtensions) break
+  }
+
+  if (!hasExtensions) {
+    // No extensions needed - export a no-op
+    lines.push('/**')
+    lines.push(' * No result extensions configured')
+    lines.push(' */')
+    lines.push('export const prismaExtensions = {}')
+    lines.push('')
+    return lines.join('\n')
+  }
+
+  // Generate result extensions
+  lines.push('/**')
+  lines.push(' * Prisma result extensions for field transformations and virtual fields')
+  lines.push(' * Delegates to field resolveOutput hooks from config for runtime transformations')
+  lines.push(' */')
+  lines.push('export const prismaExtensions = Prisma.defineExtension({')
+  lines.push('  result: {')
+
+  // Generate extensions for each list
+  for (const [listName, listConfig] of Object.entries(config.lists)) {
+    // Include both fields with resultExtension AND virtual fields
+    const fieldsWithExtensions: Array<[string, FieldConfig]> = Object.entries(
+      listConfig.fields,
+    ).filter(([_, config]) => config.resultExtension || config.virtual)
+
+    if (fieldsWithExtensions.length === 0) continue
+
+    const modelKey = listName.charAt(0).toLowerCase() + listName.slice(1) // camelCase
+
+    lines.push(`    ${modelKey}: {`)
+
+    for (const [fieldName, fieldConfig] of fieldsWithExtensions) {
+      const isVirtual = fieldConfig.virtual
+
+      lines.push(`      ${fieldName}: {`)
+
+      if (isVirtual) {
+        // Virtual fields don't need database fields - they compute from the full item
+        lines.push(`        needs: {},`)
+      } else {
+        // Non-virtual fields need their database value
+        lines.push(`        needs: { ${fieldName}: true },`)
+      }
+
+      lines.push(`        compute: (${modelKey}) => {`)
+
+      if (!isVirtual) {
+        // For non-virtual fields, get the database value and check nullability
+        lines.push(`          const value = ${modelKey}.${fieldName}`)
+        lines.push(`          if (value === null || value === undefined) {`)
+        lines.push(`            return undefined`)
+        lines.push(`          }`)
+      }
+
+      lines.push(`          // Call field's resolveOutput hook if available (synchronously)`)
+      lines.push(`          if (!resolvedConfig) {`)
+      lines.push(
+        `            // Config not yet resolved - return undefined for virtual, value for regular`,
+      )
+      if (isVirtual) {
+        lines.push(`            return undefined`)
+      } else {
+        lines.push(`            return value`)
+      }
+      lines.push(`          }`)
+      lines.push(
+        `          const fieldConfig = resolvedConfig.lists['${listName}'].fields['${fieldName}']`,
+      )
+      lines.push(`          if (fieldConfig.hooks?.resolveOutput) {`)
+      lines.push(`            return fieldConfig.hooks.resolveOutput({`)
+      lines.push(`              operation: 'query',`)
+      if (isVirtual) {
+        lines.push(`              value: undefined, // Virtual fields have no stored value`)
+      } else {
+        lines.push(`              value,`)
+      }
+      lines.push(`              item: ${modelKey},`)
+      lines.push(`              listKey: '${listName}',`)
+      lines.push(`              fieldName: '${fieldName}',`)
+      lines.push(
+        `              context: null as any, // Extension context doesn't have full context`,
+      )
+      lines.push(`            })`)
+      lines.push(`          }`)
+      if (isVirtual) {
+        lines.push(`          return undefined`)
+      } else {
+        lines.push(`          return value`)
+      }
+      lines.push(`        },`)
+      lines.push(`      },`)
+    }
+
+    lines.push(`    },`)
+  }
+
+  lines.push('  },')
+  lines.push('})')
+  lines.push('')
+
+  return lines.join('\n')
+}
+
+/**
+ * Write Prisma extensions configuration to file
+ */
+export function writePrismaExtensions(config: OpenSaasConfig, outputPath: string): void {
+  const extensions = generatePrismaExtensions(config)
+
+  // Ensure directory exists
+  const dir = path.dirname(outputPath)
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true })
+  }
+
+  fs.writeFileSync(outputPath, extensions, 'utf-8')
+}

package/src/generator/prisma.ts

@@ -90,6 +90,11 @@ export function generatePrismaSchema(config: OpenSaasConfig): string {
 
     // 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,

package/src/generator/types.ts

@@ -41,24 +41,96 @@ function isFieldOptional(field: FieldConfig): boolean {
 }
 
 /**
- * Generate TypeScript interface for a model
+ * Generate virtual fields type - only contains virtual fields
+ * This is intersected with Prisma's GetPayload to add virtual fields to query results
  */
-function generateModelType(listName: string, fields: Record<string, FieldConfig>): string {
+function generateVirtualFieldsType(listName: string, fields: Record<string, FieldConfig>): string {
   const lines: string[] = []
+  const virtualFields = Object.entries(fields).filter(([_, config]) => config.type === 'virtual')
 
-  lines.push(`export type ${listName} = {`)
+  lines.push(`/**`)
+  lines.push(` * Virtual fields for ${listName} - computed fields not in database`)
+  lines.push(` * These are added to query results via resolveOutput hooks`)
+  lines.push(` */`)
+  lines.push(`export type ${listName}VirtualFields = {`)
+
+  for (const [fieldName, fieldConfig] of virtualFields) {
+    const tsType = mapFieldTypeToTypeScript(fieldConfig)
+    if (!tsType) continue
+
+    const optional = isFieldOptional(fieldConfig)
+    const nullability = optional ? ' | null' : ''
+    lines.push(`  ${fieldName}: ${tsType}${nullability}`)
+  }
+
+  // If no virtual fields, make it an empty object
+  if (virtualFields.length === 0) {
+    lines.push('  // No virtual fields defined')
+  }
+
+  lines.push('}')
+
+  return lines.join('\n')
+}
+
+/**
+ * Generate transformed fields type - fields with resultExtension transformations
+ * This replaces Prisma's base types with transformed types (e.g., string -> HashedPassword)
+ */
+function generateTransformedFieldsType(
+  listName: string,
+  fields: Record<string, FieldConfig>,
+): string {
+  const lines: string[] = []
+  const transformedFields = Object.entries(fields).filter(([_, config]) => config.resultExtension)
+
+  lines.push(`/**`)
+  lines.push(` * Transformed fields for ${listName} - fields with resultExtension transformations`)
+  lines.push(` * These override Prisma's base types with transformed types via result extensions`)
+  lines.push(` */`)
+  lines.push(`export type ${listName}TransformedFields = {`)
+
+  for (const [fieldName, fieldConfig] of transformedFields) {
+    if (fieldConfig.resultExtension) {
+      const optional = isFieldOptional(fieldConfig)
+      const nullability = optional ? ' | undefined' : ''
+      lines.push(`  ${fieldName}: ${fieldConfig.resultExtension.outputType}${nullability}`)
+    }
+  }
+
+  // If no transformed fields, make it an empty object
+  if (transformedFields.length === 0) {
+    lines.push('  // No transformed fields defined')
+  }
+
+  lines.push('}')
+
+  return lines.join('\n')
+}
+
+/**
+ * Generate TypeScript Output type for a model (includes virtual fields)
+ * This is kept for backwards compatibility but CustomDB uses Prisma's GetPayload + VirtualFields
+ */
+function generateModelOutputType(listName: string, fields: Record<string, FieldConfig>): string {
+  const lines: string[] = []
+
+  lines.push(`export type ${listName}Output = {`)
   lines.push('  id: string')
 
   for (const [fieldName, fieldConfig] of Object.entries(fields)) {
+    // Skip virtual fields - they're in VirtualFields type
+    if (fieldConfig.type === 'virtual') continue
+
     if (fieldConfig.type === 'relationship') {
       const relField = fieldConfig as RelationshipField
       const [targetList] = relField.ref.split('.')
 
       if (relField.many) {
-        lines.push(`  ${fieldName}: ${targetList}[]`)
+        lines.push(`  ${fieldName}?: ${targetList}Output[]`) // Optional since only present with include
       } else {
         lines.push(`  ${fieldName}Id: string | null`)
-        lines.push(`  ${fieldName}: ${targetList} | null`)
+        lines.push(`  ${fieldName}?: ${targetList}Output | null`) // Optional since only present with include
       }
     } else {
       const tsType = mapFieldTypeToTypeScript(fieldConfig)
@@ -72,11 +144,18 @@ function generateModelType(listName: string, fields: Record<string, FieldConfig>
 
   lines.push('  createdAt: Date')
   lines.push('  updatedAt: Date')
-  lines.push('}')
+  lines.push('} & ' + listName + 'VirtualFields') // Include virtual fields
 
   return lines.join('\n')
 }
 
+/**
+ * Generate convenience type alias (List = ListOutput)
+ */
+function generateModelTypeAlias(listName: string): string {
+  return `export type ${listName} = ${listName}Output`
+}
+
 /**
  * Generate CreateInput type
  */
@@ -86,6 +165,12 @@ function generateCreateInputType(listName: string, fields: Record<string, FieldC
   lines.push(`export type ${listName}CreateInput = {`)
 
   for (const [fieldName, fieldConfig] of Object.entries(fields)) {
+    // Skip virtual fields - they don't accept input in create operations
+    // Virtual fields with resolveInput hooks handle side effects but don't store data
+    if (fieldConfig.virtual) {
+      continue
+    }
+
     if (fieldConfig.type === 'relationship') {
       const relField = fieldConfig as RelationshipField
 
@@ -118,6 +203,12 @@ function generateUpdateInputType(listName: string, fields: Record<string, FieldC
   lines.push(`export type ${listName}UpdateInput = {`)
 
   for (const [fieldName, fieldConfig] of Object.entries(fields)) {
+    // Virtual fields with resolveInput hooks can accept input for side effects
+    // but we still skip them in the input type since they don't store data
+    if (fieldConfig.virtual) {
+      continue
+    }
+
     if (fieldConfig.type === 'relationship') {
       const relField = fieldConfig as RelationshipField
 
@@ -219,20 +310,104 @@ function generateHookTypes(listName: string): string {
 }
 
 /**
- * Generate Context type with all operations
+ * Generate custom DB interface that uses Prisma's conditional types with virtual and transformed fields
+ * This leverages Prisma's GetPayload utility to get correct types based on select/include
+ */
+function generateCustomDBType(config: OpenSaasConfig): string {
+  const lines: string[] = []
+
+  // Generate list of db keys to omit from AccessControlledDB
+  const dbKeys = Object.keys(config.lists).map((listName) => {
+    const dbKey = listName.charAt(0).toLowerCase() + listName.slice(1)
+    return `'${dbKey}'`
+  })
+
+  lines.push('/**')
+  lines.push(
+    " * Custom DB type that uses Prisma's conditional types with virtual and transformed field support",
+  )
+  lines.push(
+    ' * Types change based on select/include - relationships only present when explicitly included',
+  )
+  lines.push(' * Virtual fields and transformed fields are added to the base model type')
+  lines.push(' */')
+  lines.push('export type CustomDB = Omit<AccessControlledDB<PrismaClient>, ')
+  lines.push(`  ${dbKeys.join(' | ')}`)
+  lines.push('> & {')
+
+  // For each list, create strongly-typed methods using Prisma's conditional types
+  for (const listName of Object.keys(config.lists)) {
+    const dbKey = listName.charAt(0).toLowerCase() + listName.slice(1) // camelCase
+
+    lines.push(`  ${dbKey}: {`)
+
+    // findUnique - generic to preserve Prisma's conditional return type
+    lines.push(`    findUnique: <T extends Prisma.${listName}FindUniqueArgs>(`)
+    lines.push(`      args: Prisma.SelectSubset<T, Prisma.${listName}FindUniqueArgs>`)
+    lines.push(
+      `    ) => Promise<(Omit<Prisma.${listName}GetPayload<T>, keyof ${listName}TransformedFields> & ${listName}TransformedFields & ${listName}VirtualFields) | null>`,
+    )
+
+    // findMany - generic to preserve Prisma's conditional return type
+    lines.push(`    findMany: <T extends Prisma.${listName}FindManyArgs>(`)
+    lines.push(`      args?: Prisma.SelectSubset<T, Prisma.${listName}FindManyArgs>`)
+    lines.push(
+      `    ) => Promise<Array<Omit<Prisma.${listName}GetPayload<T>, keyof ${listName}TransformedFields> & ${listName}TransformedFields & ${listName}VirtualFields>>`,
+    )
+
+    // create - generic to preserve Prisma's conditional return type
+    lines.push(`    create: <T extends Prisma.${listName}CreateArgs>(`)
+    lines.push(`      args: Prisma.SelectSubset<T, Prisma.${listName}CreateArgs>`)
+    lines.push(
+      `    ) => Promise<Omit<Prisma.${listName}GetPayload<T>, keyof ${listName}TransformedFields> & ${listName}TransformedFields & ${listName}VirtualFields>`,
+    )
+
+    // update - generic to preserve Prisma's conditional return type
+    lines.push(`    update: <T extends Prisma.${listName}UpdateArgs>(`)
+    lines.push(`      args: Prisma.SelectSubset<T, Prisma.${listName}UpdateArgs>`)
+    lines.push(
+      `    ) => Promise<(Omit<Prisma.${listName}GetPayload<T>, keyof ${listName}TransformedFields> & ${listName}TransformedFields & ${listName}VirtualFields) | null>`,
+    )
+
+    // delete - generic to preserve Prisma's conditional return type
+    lines.push(`    delete: <T extends Prisma.${listName}DeleteArgs>(`)
+    lines.push(`      args: Prisma.SelectSubset<T, Prisma.${listName}DeleteArgs>`)
+    lines.push(
+      `    ) => Promise<(Omit<Prisma.${listName}GetPayload<T>, keyof ${listName}TransformedFields> & ${listName}TransformedFields & ${listName}VirtualFields) | null>`,
+    )
+
+    // count - no changes to return type
+    lines.push(`    count: (args?: Prisma.${listName}CountArgs) => Promise<number>`)
+
+    lines.push(`  }`)
+  }
+
+  lines.push('}')
+
+  return lines.join('\n')
+}
+
+/**
+ * Generate Context type that is compatible with AccessContext
  */
-function generateContextType(): string {
+function generateContextType(_config: OpenSaasConfig): string {
   const lines: string[] = []
 
-  lines.push('export type Context<TSession extends OpensaasSession = OpensaasSession> = {')
-  lines.push('  db: AccessControlledDB<PrismaClient>')
+  lines.push('/**')
+  lines.push(
+    ' * Context type compatible with AccessContext but with CustomDB for virtual field typing',
+  )
+  lines.push(
+    ' * Extends AccessContext and overrides db property to include virtual fields in output types',
+  )
+  lines.push(' */')
+  lines.push(
+    "export type Context<TSession extends OpensaasSession = OpensaasSession> = Omit<AccessContext<PrismaClient>, 'db' | 'session'> & {",
+  )
+  lines.push('  db: CustomDB')
   lines.push('  session: TSession')
-  lines.push('  prisma: PrismaClient')
-  lines.push('  storage: StorageUtils')
-  lines.push('  plugins: PluginServices')
   lines.push('  serverAction: (props: ServerActionProps) => Promise<unknown>')
   lines.push('  sudo: () => Context<TSession>')
-  lines.push('  _isSudo: boolean')
   lines.push('}')
 
   return lines.join('\n')
@@ -299,7 +474,7 @@ export function generateTypes(config: OpenSaasConfig): string {
   // Add necessary imports
   // Use alias for Session to avoid conflicts if user has a list named "Session"
   lines.push(
-    "import type { Session as OpensaasSession, StorageUtils, ServerActionProps, AccessControlledDB } from '@opensaas/stack-core'",
+    "import type { Session as OpensaasSession, StorageUtils, ServerActionProps, AccessControlledDB, AccessContext } from '@opensaas/stack-core'",
   )
   lines.push("import type { PrismaClient, Prisma } from './prisma-client/client'")
   lines.push("import type { PluginServices } from './plugin-types'")
@@ -316,7 +491,15 @@ export function generateTypes(config: OpenSaasConfig): string {
 
   // Generate types for each list
   for (const [listName, listConfig] of Object.entries(config.lists)) {
-    lines.push(generateModelType(listName, listConfig.fields))
+    // Generate VirtualFields type first (needed by Output type and CustomDB)
+    lines.push(generateVirtualFieldsType(listName, listConfig.fields))
+    lines.push('')
+    // Generate TransformedFields type (needed by CustomDB)
+    lines.push(generateTransformedFieldsType(listName, listConfig.fields))
+    lines.push('')
+    lines.push(generateModelOutputType(listName, listConfig.fields))
+    lines.push('')
+    lines.push(generateModelTypeAlias(listName))
     lines.push('')
     lines.push(generateCreateInputType(listName, listConfig.fields))
     lines.push('')
@@ -328,8 +511,12 @@ export function generateTypes(config: OpenSaasConfig): string {
     lines.push('')
   }
 
+  // Generate CustomDB interface
+  lines.push(generateCustomDBType(config))
+  lines.push('')
+
   // Generate Context type
-  lines.push(generateContextType())
+  lines.push(generateContextType(config))
 
   return lines.join('\n')
 }

package/src/index.ts

@@ -5,6 +5,7 @@ import { generateCommand } from './commands/generate.js'
 import { initCommand } from './commands/init.js'
 import { devCommand } from './commands/dev.js'
 import { createMCPCommand } from './commands/mcp.js'
+import { createMigrateCommand } from './commands/migrate.js'
 
 const program = new Command()
 
@@ -39,4 +40,7 @@ program
 // Add MCP command group
 program.addCommand(createMCPCommand())
 
+// Add migrate command
+program.addCommand(createMigrateCommand())
+
 program.parse()