@opensaas/stack-cli 0.1.7 → 0.4.0

package/src/generator/context.test.ts

@@ -9,7 +9,8 @@ describe('Context Generator', () => {
       const config: OpenSaasConfig = {
         db: {
           provider: 'sqlite',
-          url: 'file:./dev.db',
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          prismaClientConstructor: (() => null) as any,
         },
         lists: {
           User: {
@@ -29,7 +30,6 @@ describe('Context Generator', () => {
       const config: OpenSaasConfig = {
         db: {
           provider: 'postgresql',
-          url: process.env.DATABASE_URL || 'postgresql://localhost:5432/db',
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           prismaClientConstructor: ((PrismaClient: any) => new PrismaClient()) as any,
         },
@@ -51,7 +51,8 @@ describe('Context Generator', () => {
       const config: OpenSaasConfig = {
         db: {
           provider: 'sqlite',
-          url: 'file:./dev.db',
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          prismaClientConstructor: (() => null) as any,
         },
         lists: {},
       }
@@ -59,7 +60,9 @@ describe('Context Generator', () => {
       const context = generateContext(config)
 
       expect(context).toContain('const globalForPrisma')
-      expect(context).toContain('globalThis as unknown as { prisma: PrismaClient | undefined }')
+      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')")
     })
@@ -68,7 +71,8 @@ describe('Context Generator', () => {
       const config: OpenSaasConfig = {
         db: {
           provider: 'sqlite',
-          url: 'file:./dev.db',
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          prismaClientConstructor: (() => null) as any,
         },
         lists: {},
       }
@@ -87,7 +91,8 @@ describe('Context Generator', () => {
       const config: OpenSaasConfig = {
         db: {
           provider: 'sqlite',
-          url: 'file:./dev.db',
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          prismaClientConstructor: (() => null) as any,
         },
         lists: {},
       }
@@ -104,7 +109,8 @@ describe('Context Generator', () => {
       const config: OpenSaasConfig = {
         db: {
           provider: 'sqlite',
-          url: 'file:./dev.db',
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          prismaClientConstructor: (() => null) as any,
         },
         lists: {},
       }
@@ -118,7 +124,8 @@ describe('Context Generator', () => {
       const config: OpenSaasConfig = {
         db: {
           provider: 'sqlite',
-          url: 'file:./dev.db',
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          prismaClientConstructor: (() => null) as any,
         },
         lists: {},
       }

package/src/generator/context.ts

@@ -16,9 +16,27 @@ export function generateContext(config: OpenSaasConfig): string {
   const hasStorage = !!config.storage && Object.keys(config.storage).length > 0
 
   // Generate the Prisma client instantiation code
+  // Prisma 7 requires adapters, so prismaClientConstructor must be provided
   const prismaInstantiation = hasCustomConstructor
     ? `resolvedConfig.db.prismaClientConstructor!(PrismaClient)`
-    : `new PrismaClient()`
+    : `(() => {
+      throw new Error(
+        'Prisma 7 requires a database adapter. Please add prismaClientConstructor to your opensaas.config.ts db configuration.\\n\\n' +
+        'Example for SQLite:\\n' +
+        'import { PrismaBetterSQLite3 } from \\'@prisma/adapter-better-sqlite3\\'\\n' +
+        'import Database from \\'better-sqlite3\\'\\n\\n' +
+        'db: {\\n' +
+        '  provider: \\'sqlite\\',\\n' +
+        '  url: process.env.DATABASE_URL || \\'file:./dev.db\\',\\n' +
+        '  prismaClientConstructor: (PrismaClient) => {\\n' +
+        '    const db = new Database(process.env.DATABASE_URL || \\'./dev.db\\')\\n' +
+        '    const adapter = new PrismaBetterSQLite3(db)\\n' +
+        '    return new PrismaClient({ adapter })\\n' +
+        '  }\\n' +
+        '}\\n\\n' +
+        'See https://www.prisma.io/docs/orm/overview/databases/database-drivers for more information.'
+      )
+    })()`
 
   // Generate storage utilities if storage is configured
   const storageUtilities = hasStorage
@@ -103,8 +121,9 @@ const storage = {
 
 import { getContext as getOpensaasContext } from '@opensaas/stack-core'
 import type { Session as OpensaasSession, OpenSaasConfig } from '@opensaas/stack-core'
-import { PrismaClient } from './prisma-client'
+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)
@@ -112,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 | undefined }
-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
@@ -157,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>
 }
 
 /**
@@ -167,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

@@ -1,4 +1,7 @@
 export { generatePrismaSchema, writePrismaSchema } from './prisma.js'
+export { generatePrismaConfig, writePrismaConfig } from './prisma-config.js'
 export { generateTypes, writeTypes } from './types.js'
-export { patchPrismaTypes } from './type-patcher.js'
+export { generateListsNamespace, writeLists } from './lists.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.test.ts

@@ -0,0 +1,335 @@
+import { describe, it, expect } from 'vitest'
+import { generateListsNamespace } from './lists.js'
+import type { OpenSaasConfig } from '@opensaas/stack-core'
+import { text, integer, relationship, checkbox } from '@opensaas/stack-core/fields'
+
+describe('Lists Namespace Generator', () => {
+  describe('generateListsNamespace', () => {
+    it('should generate Lists namespace for single list', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+        },
+        lists: {
+          Post: {
+            fields: {
+              title: text({ validation: { isRequired: true } }),
+              content: text(),
+            },
+          },
+        },
+      }
+
+      const lists = generateListsNamespace(config)
+
+      expect(lists).toContain('export declare namespace Lists {')
+      expect(lists).toContain('export type Post')
+      expect(lists).toContain('namespace Post {')
+      expect(lists).toContain("export type Item = import('./types').Post")
+      expect(lists).toContain('export type TypeInfo')
+      expect(lists).toContain("key: 'Post'")
+      expect(lists).toContain('item: Item')
+      expect(lists).toContain('inputs: {')
+      expect(lists).toContain("create: import('./prisma-client/client').Prisma.PostCreateInput")
+      expect(lists).toContain("update: import('./prisma-client/client').Prisma.PostUpdateInput")
+    })
+
+    it('should generate Lists namespace for multiple lists', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+        },
+        lists: {
+          User: {
+            fields: {
+              name: text(),
+              email: text(),
+            },
+          },
+          Post: {
+            fields: {
+              title: text(),
+            },
+          },
+          Comment: {
+            fields: {
+              content: text(),
+            },
+          },
+        },
+      }
+
+      const lists = generateListsNamespace(config)
+
+      // Check all three lists are present
+      expect(lists).toContain('export type User')
+      expect(lists).toContain('export type Post')
+      expect(lists).toContain('export type Comment')
+
+      // Check all three namespaces
+      expect(lists).toContain('namespace User {')
+      expect(lists).toContain('namespace Post {')
+      expect(lists).toContain('namespace Comment {')
+
+      // Check TypeInfo for each
+      expect(lists).toContain("key: 'User'")
+      expect(lists).toContain("key: 'Post'")
+      expect(lists).toContain("key: 'Comment'")
+    })
+
+    it('should include header comment with usage examples', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+        },
+        lists: {
+          Post: {
+            fields: {
+              title: text(),
+            },
+          },
+        },
+      }
+
+      const lists = generateListsNamespace(config)
+
+      expect(lists).toContain('/**')
+      expect(lists).toContain('Generated Lists namespace from OpenSaas configuration')
+      expect(lists).toContain('DO NOT EDIT')
+      expect(lists).toContain('@example')
+      expect(lists).toContain('import type { Lists }')
+      expect(lists).toContain('list<Lists.Post.TypeInfo>')
+      expect(lists).toContain('const Post: Lists.Post = list')
+    })
+
+    it('should reference correct import paths', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+        },
+        lists: {
+          User: {
+            fields: {
+              name: text(),
+            },
+          },
+        },
+      }
+
+      const lists = generateListsNamespace(config)
+
+      // Check ListConfig import
+      expect(lists).toContain("import('@opensaas/stack-core').ListConfig")
+
+      // Check Item import
+      expect(lists).toContain("import('./types').User")
+
+      // Check Prisma imports
+      expect(lists).toContain("import('./prisma-client/client').Prisma.UserCreateInput")
+      expect(lists).toContain("import('./prisma-client/client').Prisma.UserUpdateInput")
+    })
+
+    it('should generate TypeInfo structure correctly', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+        },
+        lists: {
+          Post: {
+            fields: {
+              title: text(),
+            },
+          },
+        },
+      }
+
+      const lists = generateListsNamespace(config)
+
+      // Verify TypeInfo structure
+      expect(lists).toContain('export type TypeInfo = {')
+      expect(lists).toContain("key: 'Post'")
+      expect(lists).toContain('item: Item')
+      expect(lists).toContain('inputs: {')
+      expect(lists).toContain('create:')
+      expect(lists).toContain('update:')
+    })
+
+    it('should handle lists with relationships', () => {
+      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 lists = generateListsNamespace(config)
+
+      // Both lists should be generated
+      expect(lists).toContain('export type User')
+      expect(lists).toContain('export type Post')
+
+      // Prisma input types should still reference correct types
+      expect(lists).toContain('Prisma.UserCreateInput')
+      expect(lists).toContain('Prisma.PostCreateInput')
+      expect(lists).toContain('Prisma.UserUpdateInput')
+      expect(lists).toContain('Prisma.PostUpdateInput')
+    })
+
+    it('should handle lists with various field types', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+        },
+        lists: {
+          Product: {
+            fields: {
+              name: text(),
+              price: integer(),
+              isAvailable: checkbox(),
+            },
+          },
+        },
+      }
+
+      const lists = generateListsNamespace(config)
+
+      // TypeInfo should be generated regardless of field types
+      expect(lists).toContain('export type Product')
+      expect(lists).toContain('namespace Product {')
+      expect(lists).toContain('export type TypeInfo')
+      expect(lists).toContain('Prisma.ProductCreateInput')
+      expect(lists).toContain('Prisma.ProductUpdateInput')
+    })
+
+    it('should close namespace properly', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+        },
+        lists: {
+          User: {
+            fields: {
+              name: text(),
+            },
+          },
+        },
+      }
+
+      const lists = generateListsNamespace(config)
+
+      // Should have closing brace for namespace
+      expect(lists).toMatch(/}\s*$/)
+    })
+
+    it('should generate for empty lists object', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+        },
+        lists: {},
+      }
+
+      const lists = generateListsNamespace(config)
+
+      // Should still have namespace declaration
+      expect(lists).toContain('export declare namespace Lists {')
+      expect(lists).toContain('}')
+      expect(lists).toContain('/**')
+    })
+
+    it('should maintain consistent formatting', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+        },
+        lists: {
+          Post: {
+            fields: {
+              title: text(),
+            },
+          },
+        },
+      }
+
+      const lists = generateListsNamespace(config)
+
+      // Check indentation consistency
+      expect(lists).toContain('  export type Post')
+      expect(lists).toContain('  namespace Post {')
+      expect(lists).toContain('    export type Item')
+      expect(lists).toContain('    export type TypeInfo')
+      expect(lists).toContain('      key:')
+      expect(lists).toContain('      item:')
+      expect(lists).toContain('      inputs: {')
+      expect(lists).toContain('        create:')
+      expect(lists).toContain('        update:')
+    })
+
+    it('should handle list names with special casing', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+        },
+        lists: {
+          BlogPost: {
+            fields: {
+              title: text(),
+            },
+          },
+          APIKey: {
+            fields: {
+              key: text(),
+            },
+          },
+        },
+      }
+
+      const lists = generateListsNamespace(config)
+
+      // Should preserve exact casing from config
+      expect(lists).toContain('export type BlogPost')
+      expect(lists).toContain('export type APIKey')
+      expect(lists).toContain('namespace BlogPost {')
+      expect(lists).toContain('namespace APIKey {')
+      expect(lists).toContain("key: 'BlogPost'")
+      expect(lists).toContain("key: 'APIKey'")
+      expect(lists).toContain('Prisma.BlogPostCreateInput')
+      expect(lists).toContain('Prisma.APIKeyCreateInput')
+    })
+
+    it('should connect List type to TypeInfo via ListConfig generic', () => {
+      const config: OpenSaasConfig = {
+        db: {
+          provider: 'sqlite',
+        },
+        lists: {
+          Post: {
+            fields: {
+              title: text(),
+            },
+          },
+        },
+      }
+
+      const lists = generateListsNamespace(config)
+
+      // Verify the List type uses ListConfig with TypeInfo
+      expect(lists).toContain(
+        "export type Post = import('@opensaas/stack-core').ListConfig<Lists.Post.TypeInfo>",
+      )
+    })
+  })
+})

package/src/generator/lists.ts

@@ -0,0 +1,140 @@
+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
+ *
+ * @example
+ * ```typescript
+ * // Generated output:
+ * export declare namespace Lists {
+ *   export type Post = import('@opensaas/stack-core').ListConfig<Lists.Post.TypeInfo>
+ *
+ *   namespace Post {
+ *     export type Item = import('./types').Post
+ *     export type TypeInfo = {
+ *       key: 'Post'
+ *       item: Item
+ *       inputs: {
+ *         create: import('./prisma-client/client').Prisma.PostCreateInput
+ *         update: import('./prisma-client/client').Prisma.PostUpdateInput
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export function generateListsNamespace(config: OpenSaasConfig): string {
+  const lines: string[] = []
+
+  // Add header comment
+  lines.push('/**')
+  lines.push(' * Generated Lists namespace from OpenSaas configuration')
+  lines.push(' * DO NOT EDIT - This file is automatically generated')
+  lines.push(' *')
+  lines.push(' * This file provides TypeInfo for each list, enabling strong typing')
+  lines.push(' * for hooks with Prisma input types.')
+  lines.push(' *')
+  lines.push(' * @example')
+  lines.push(' * ```typescript')
+  lines.push(" * import type { Lists } from './.opensaas/lists'")
+  lines.push(' *')
+  lines.push(' * // Use TypeInfo as generic parameter')
+  lines.push(' * Post: list<Lists.Post.TypeInfo>({')
+  lines.push(' *   hooks: {')
+  lines.push(' *     resolveInput: async ({ operation, resolvedData }) => {')
+  lines.push(' *       // resolvedData is Prisma.PostCreateInput or Prisma.PostUpdateInput')
+  lines.push(' *       return resolvedData')
+  lines.push(' *     }')
+  lines.push(' *   }')
+  lines.push(' * })')
+  lines.push(' *')
+  lines.push(' * // Or use as typed constant')
+  lines.push(' * const Post: Lists.Post = list({ ... })')
+  lines.push(' * ```')
+  lines.push(' */')
+  lines.push('')
+
+  // Start Lists namespace
+  lines.push('export declare namespace Lists {')
+
+  // Generate type for each list
+  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`)
+    lines.push(`        update: import('./prisma-client/client').Prisma.${listName}UpdateInput`)
+    lines.push(`      }`)
+    lines.push(`    }`)
+    lines.push(`  }`)
+    lines.push('')
+  }
+
+  // Close Lists namespace
+  lines.push('}')
+
+  return lines.join('\n')
+}
+
+/**
+ * Write Lists namespace to file
+ */
+export function writeLists(config: OpenSaasConfig, outputPath: string): void {
+  const lists = generateListsNamespace(config)
+
+  // Ensure directory exists
+  const dir = path.dirname(outputPath)
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true })
+  }
+
+  fs.writeFileSync(outputPath, lists, 'utf-8')
+}