@opensaas/stack-cli 0.5.0 → 0.6.0

package/src/generator/context.test.ts

@@ -1,139 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { generateContext } from './context.js'
-import type { OpenSaasConfig } from '@opensaas/stack-core'
-import { text } from '@opensaas/stack-core/fields'
-
-describe('Context Generator', () => {
-  describe('generateContext', () => {
-    it('should generate context factory with default Prisma client', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          prismaClientConstructor: (() => null) as any,
-        },
-        lists: {
-          User: {
-            fields: {
-              name: text(),
-            },
-          },
-        },
-      }
-
-      const context = generateContext(config)
-
-      expect(context).toMatchSnapshot()
-    })
-
-    it('should generate context factory with custom Prisma client constructor', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'postgresql',
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          prismaClientConstructor: ((PrismaClient: any) => new PrismaClient()) as any,
-        },
-        lists: {
-          User: {
-            fields: {
-              name: text(),
-            },
-          },
-        },
-      }
-
-      const context = generateContext(config)
-
-      expect(context).toMatchSnapshot()
-    })
-
-    it('should include singleton pattern for Prisma client', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          prismaClientConstructor: (() => null) as any,
-        },
-        lists: {},
-      }
-
-      const context = generateContext(config)
-
-      expect(context).toContain('const globalForPrisma')
-      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')")
-    })
-
-    it('should include JSDoc comments', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          prismaClientConstructor: (() => null) as any,
-        },
-        lists: {},
-      }
-
-      const context = generateContext(config)
-
-      expect(context).toContain('/**')
-      expect(context).toContain('Auto-generated context factory')
-      expect(context).toContain('DO NOT EDIT')
-      expect(context).toContain('Get OpenSaas context with optional session')
-      expect(context).toContain('@param session')
-      expect(context).toContain('@example')
-    })
-
-    it('should include usage examples in comments', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          prismaClientConstructor: (() => null) as any,
-        },
-        lists: {},
-      }
-
-      const context = generateContext(config)
-
-      expect(context).toContain('// Anonymous access')
-      expect(context).toContain('const context = await getContext()')
-      expect(context).toContain('// Authenticated access')
-      expect(context).toContain("const context = await getContext({ userId: 'user-123' })")
-    })
-
-    it('should export rawOpensaasContext', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          prismaClientConstructor: (() => null) as any,
-        },
-        lists: {},
-      }
-
-      const context = generateContext(config)
-
-      expect(context).toMatchSnapshot()
-    })
-
-    it('should type session parameter correctly', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          prismaClientConstructor: (() => null) as any,
-        },
-        lists: {},
-      }
-
-      const context = generateContext(config)
-
-      expect(context).toContain('session?: TSession')
-      expect(context).toContain('<TSession extends OpensaasSession = OpensaasSession>')
-    })
-  })
-})

package/src/generator/context.ts

@@ -1,227 +0,0 @@
-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
-
-  // Check if storage is configured
-  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)`
-    : `(() => {
-      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
-    ? `
-/**
- * Lazy-loaded storage runtime functions
- * Prevents sharp and other storage dependencies from being bundled in client code
- */
-let storageRuntime: typeof import('@opensaas/stack-storage/runtime') | null = null
-
-async function getStorageRuntime() {
-  if (!storageRuntime) {
-    try {
-      storageRuntime = await import('@opensaas/stack-storage/runtime')
-    } catch (error) {
-      throw new Error(
-        'Failed to load @opensaas/stack-storage/runtime. Make sure @opensaas/stack-storage is installed.'
-      )
-    }
-  }
-  return storageRuntime
-}
-
-/**
- * Storage utilities for file/image uploads
- */
-const storage = {
-  uploadFile: async (providerName: string, file: File, buffer: Buffer, options?: unknown) => {
-    const config = await getConfig()
-    const runtime = await getStorageRuntime()
-    return runtime.uploadFile(config, providerName, { file, buffer }, options as any)
-  },
-
-  uploadImage: async (providerName: string, file: File, buffer: Buffer, options?: unknown) => {
-    const config = await getConfig()
-    const runtime = await getStorageRuntime()
-    return runtime.uploadImage(config, providerName, { file, buffer }, options as any)
-  },
-
-  deleteFile: async (providerName: string, filename: string) => {
-    const config = await getConfig()
-    const runtime = await getStorageRuntime()
-    return runtime.deleteFile(config, providerName, filename)
-  },
-
-  deleteImage: async (metadata: unknown) => {
-    const config = await getConfig()
-    const runtime = await getStorageRuntime()
-    return runtime.deleteImage(config, metadata as any)
-  },
-}
-`
-    : `
-/**
- * Storage utilities (not configured)
- */
-const storage = {
-  uploadFile: async () => {
-    throw new Error('Storage is not configured. Add storage providers to your opensaas.config.ts')
-  },
-  uploadImage: async () => {
-    throw new Error('Storage is not configured. Add storage providers to your opensaas.config.ts')
-  },
-  deleteFile: async () => {
-    throw new Error('Storage is not configured. Add storage providers to your opensaas.config.ts')
-  },
-  deleteImage: async () => {
-    throw new Error('Storage is not configured. Add storage providers to your opensaas.config.ts')
-  },
-}
-`
-
-  // Always use async version for consistency
-  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 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)
-const configPromise = Promise.resolve(configOrPromise)
-let resolvedConfig: OpenSaasConfig | null = null
-
-// Internal Prisma singleton - managed automatically
-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
-    }
-    const basePrisma = ${prismaInstantiation}
-    const extendedPrisma = createExtendedPrisma(basePrisma)
-    prisma = globalForPrisma.prisma ?? extendedPrisma
-    if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma
-  }
-  return prisma
-}
-
-async function getConfig() {
-  if (!resolvedConfig) {
-    resolvedConfig = await configPromise
-  }
-  return resolvedConfig
-}
-${storageUtilities}
-/**
- * Get OpenSaas context with optional session
- *
- * @param session - Optional session object (structure defined by your application)
- *
- * @example
- * \`\`\`typescript
- * // Anonymous access
- * const context = await getContext()
- * const posts = await context.db.post.findMany()
- *
- * // Authenticated access
- * const context = await getContext({ userId: 'user-123' })
- * const myPosts = await context.db.post.findMany()
- *
- * // With custom session type
- * type CustomSession = { userId: string; email: string; role: string } | null
- * const context = await getContext<CustomSession>({ userId: '123', email: 'user@example.com', role: 'admin' })
- * // context.session is now typed as CustomSession
- * \`\`\`
- */
-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 unknown as Context<TSession>
-}
-
-/**
- * Raw context for synchronous initialization (e.g., Better-auth setup)
- * This is only available after config is resolved, use with caution
- */
-export const rawOpensaasContext = (async () => {
-  const config = await getConfig()
-  const prismaClient = await getPrisma()
-  return getOpensaasContext(config, prismaClient, null, storage) as unknown as Context
-})()
-
-/**
- * Re-export resolved config for use in admin pages and server actions
- * This is a promise that resolves to the config
- */
-export const config = getConfig()
-`
-}
-
-/**
- * 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

@@ -1,7 +0,0 @@
-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 { 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

@@ -1,335 +0,0 @@
-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>",
-      )
-    })
-  })
-})