@opensaas/stack-cli 0.5.0 → 0.6.0

package/src/commands/dev.test.ts

@@ -1,215 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import * as fs from 'fs'
-import * as path from 'path'
-import * as os from 'os'
-
-// Mock chokidar
-const mockWatcherOn = vi.fn()
-const mockWatcherClose = vi.fn()
-const mockWatch = vi.fn(() => ({
-  on: mockWatcherOn,
-  close: mockWatcherClose,
-}))
-
-vi.mock('chokidar', () => ({
-  default: {
-    watch: mockWatch,
-  },
-}))
-
-// Mock the generate command
-vi.mock('./generate.js', () => ({
-  generateCommand: vi.fn().mockResolvedValue(undefined),
-}))
-
-// Mock ora
-vi.mock('ora', () => ({
-  default: vi.fn(() => ({
-    start: vi.fn().mockReturnThis(),
-    succeed: vi.fn().mockReturnThis(),
-    fail: vi.fn().mockReturnThis(),
-    text: '',
-  })),
-}))
-
-// Mock chalk
-vi.mock('chalk', () => ({
-  default: {
-    bold: {
-      cyan: vi.fn((str) => str),
-    },
-    cyan: vi.fn((str) => str),
-    gray: vi.fn((str) => str),
-    red: vi.fn((str) => str),
-    yellow: vi.fn((str) => str),
-  },
-}))
-
-describe('Dev Command', () => {
-  let tempDir: string
-  let originalCwd: string
-  let originalExit: typeof process.exit
-  let exitCode: number | undefined
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-
-    // Create temp directory
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dev-test-'))
-    originalCwd = process.cwd()
-    process.chdir(tempDir)
-
-    // Mock process.exit
-    originalExit = process.exit
-    exitCode = undefined
-    process.exit = vi.fn((code?: number) => {
-      exitCode = code
-      throw new Error(`process.exit(${code})`)
-    }) as never
-
-    // Create opensaas.config.ts file
-    fs.writeFileSync(
-      path.join(tempDir, 'opensaas.config.ts'),
-      `
-      import { config } from '@opensaas/stack-core'
-      export default config({
-        lists: {}
-      })
-    `,
-    )
-  })
-
-  afterEach(() => {
-    // Restore
-    process.chdir(originalCwd)
-    process.exit = originalExit
-
-    // Clean up
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true })
-    }
-  })
-
-  describe('devCommand', () => {
-    it('should fail if config file does not exist', async () => {
-      // Remove config file
-      fs.unlinkSync(path.join(tempDir, 'opensaas.config.ts'))
-
-      const { devCommand } = await import('./dev.js')
-
-      try {
-        await devCommand()
-      } catch {
-        // Expected to throw
-      }
-
-      expect(exitCode).toBe(1)
-    })
-
-    it('should call generateCommand initially', async () => {
-      const { generateCommand } = await import('./generate.js')
-      const { devCommand } = await import('./dev.js')
-
-      // Run dev command in background (don't await)
-      devCommand().catch(() => {
-        // Ignore errors
-      })
-
-      // Wait a bit for initial generation
-      await new Promise((resolve) => setTimeout(resolve, 100))
-
-      expect(generateCommand).toHaveBeenCalled()
-    })
-
-    it('should set up file watcher for config file', async () => {
-      const { devCommand } = await import('./dev.js')
-
-      // Run dev command
-      devCommand().catch(() => {
-        // Ignore errors
-      })
-
-      await new Promise((resolve) => setTimeout(resolve, 100))
-
-      // Verify watcher was set up
-      expect(mockWatch).toHaveBeenCalled()
-      expect(mockWatch.mock.calls.length).toBeGreaterThan(0)
-
-      const watchPath = mockWatch.mock.calls[0]![0]
-      expect(watchPath).toContain('opensaas.config.ts')
-
-      const watchOptions = mockWatch.mock.calls[0]![1]
-      expect(watchOptions).toMatchObject({
-        persistent: true,
-        ignoreInitial: true,
-      })
-    })
-
-    it('should register change event handler', async () => {
-      const { devCommand } = await import('./dev.js')
-
-      devCommand().catch(() => {
-        // Ignore errors
-      })
-
-      await new Promise((resolve) => setTimeout(resolve, 100))
-
-      expect(mockWatcherOn).toHaveBeenCalledWith('change', expect.any(Function))
-    })
-
-    it('should register error event handler', async () => {
-      const { devCommand } = await import('./dev.js')
-
-      devCommand().catch(() => {
-        // Ignore errors
-      })
-
-      await new Promise((resolve) => setTimeout(resolve, 100))
-
-      expect(mockWatcherOn).toHaveBeenCalledWith('error', expect.any(Function))
-    })
-
-    it('should regenerate on config file change', async () => {
-      const { generateCommand } = await import('./generate.js')
-      const { devCommand } = await import('./dev.js')
-
-      devCommand().catch(() => {
-        // Ignore errors
-      })
-
-      await new Promise((resolve) => setTimeout(resolve, 100))
-
-      // Simulate file change
-      const changeHandler = mockWatcherOn.mock.calls.find((call) => call[0] === 'change')?.[1]
-      expect(changeHandler).toBeDefined()
-
-      if (changeHandler) {
-        await changeHandler()
-      }
-
-      // generateCommand should be called again
-      expect(vi.mocked(generateCommand).mock.calls.length).toBeGreaterThan(1)
-    })
-
-    it('should close watcher on SIGINT', async () => {
-      const { devCommand } = await import('./dev.js')
-
-      devCommand().catch(() => {
-        // Ignore errors
-      })
-
-      await new Promise((resolve) => setTimeout(resolve, 100))
-
-      // Simulate SIGINT - catch the error from process.exit
-      try {
-        process.emit('SIGINT', 'SIGINT')
-      } catch {
-        // Expected to throw from process.exit mock
-      }
-
-      await new Promise((resolve) => setTimeout(resolve, 100))
-
-      expect(mockWatcherClose).toHaveBeenCalled()
-    })
-  })
-})

package/src/commands/dev.ts

@@ -1,48 +0,0 @@
-import * as path from 'path'
-import * as fs from 'fs'
-import chalk from 'chalk'
-import chokidar from 'chokidar'
-import { generateCommand } from './generate.js'
-
-export async function devCommand() {
-  const cwd = process.cwd()
-  const configPath = path.join(cwd, 'opensaas.config.ts')
-
-  // Check if config exists
-  if (!fs.existsSync(configPath)) {
-    console.error(chalk.red('Error: opensaas.config.ts not found in current directory'))
-    console.error(chalk.gray('   Please run this command from your project root'))
-    process.exit(1)
-  }
-
-  console.log(chalk.bold.cyan('\nOpenSaas Dev Mode\n'))
-  console.log(chalk.gray('Watching for changes to opensaas.config.ts...\n'))
-
-  // Run initial generation
-  await generateCommand()
-
-  // Watch for changes
-  const watcher = chokidar.watch(configPath, {
-    persistent: true,
-    ignoreInitial: true,
-  })
-
-  watcher.on('change', async () => {
-    console.log(chalk.yellow('\nConfig changed, regenerating...\n'))
-    await generateCommand()
-  })
-
-  watcher.on('error', (error) => {
-    console.error(chalk.red('\nWatcher error:'), error)
-  })
-
-  // Keep the process running
-  console.log(chalk.gray('Press Ctrl+C to stop watching\n'))
-
-  // Handle graceful shutdown
-  process.on('SIGINT', () => {
-    console.log(chalk.yellow('\n\nStopping dev mode...'))
-    watcher.close()
-    process.exit(0)
-  })
-}

package/src/commands/generate.test.ts

@@ -1,282 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import * as fs from 'fs'
-import * as path from 'path'
-import * as os from 'os'
-import type { OpenSaasConfig } from '@opensaas/stack-core'
-import { text } from '@opensaas/stack-core/fields'
-import { writePrismaSchema, writeTypes, writeContext } from '../generator/index.js'
-
-// Mock ora module
-vi.mock('ora', () => ({
-  default: vi.fn(() => ({
-    start: vi.fn().mockReturnThis(),
-    succeed: vi.fn().mockReturnThis(),
-    fail: vi.fn().mockReturnThis(),
-    text: '',
-  })),
-}))
-
-// Mock chalk module
-vi.mock('chalk', () => ({
-  default: {
-    bold: vi.fn((str) => str),
-    cyan: vi.fn((str) => str),
-    gray: vi.fn((str) => str),
-    red: vi.fn((str) => str),
-    yellow: vi.fn((str) => str),
-    green: vi.fn((str) => str),
-  },
-}))
-
-describe('Generate Command Integration', () => {
-  let tempDir: string
-
-  beforeEach(() => {
-    // Create temp directory for testing
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'generate-test-'))
-  })
-
-  afterEach(() => {
-    // Clean up
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true })
-    }
-  })
-
-  describe('Generator Integration', () => {
-    it('should generate all files for a basic config', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          prismaClientConstructor: (() => null) as any,
-        },
-        lists: {
-          User: {
-            fields: {
-              name: text({ validation: { isRequired: true } }),
-              email: text({ validation: { isRequired: true } }),
-            },
-          },
-        },
-      }
-
-      // Generate files
-      const prismaPath = path.join(tempDir, 'prisma', 'schema.prisma')
-      const typesPath = path.join(tempDir, '.opensaas', 'types.ts')
-      const contextPath = path.join(tempDir, '.opensaas', 'context.ts')
-
-      writePrismaSchema(config, prismaPath)
-      writeTypes(config, typesPath)
-      writeContext(config, contextPath)
-
-      // Verify all files exist
-      expect(fs.existsSync(prismaPath)).toBe(true)
-      expect(fs.existsSync(typesPath)).toBe(true)
-      expect(fs.existsSync(contextPath)).toBe(true)
-
-      // Verify file contents with snapshots
-      const prismaSchema = fs.readFileSync(prismaPath, 'utf-8')
-      expect(prismaSchema).toMatchSnapshot('prisma-schema')
-
-      const types = fs.readFileSync(typesPath, 'utf-8')
-      expect(types).toMatchSnapshot('types')
-
-      const context = fs.readFileSync(contextPath, 'utf-8')
-      expect(context).toMatchSnapshot('context')
-    })
-
-    it('should create directories if they do not exist', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          prismaClientConstructor: (() => null) as any,
-        },
-        lists: {},
-      }
-
-      const prismaPath = path.join(tempDir, 'prisma', 'schema.prisma')
-
-      writePrismaSchema(config, prismaPath)
-
-      expect(fs.existsSync(path.join(tempDir, 'prisma'))).toBe(true)
-      expect(fs.existsSync(prismaPath)).toBe(true)
-    })
-
-    it('should overwrite existing files', () => {
-      const config1: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          prismaClientConstructor: (() => null) as any,
-        },
-        lists: {
-          User: {
-            fields: {
-              name: text(),
-            },
-          },
-        },
-      }
-
-      const config2: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          prismaClientConstructor: (() => null) as any,
-        },
-        lists: {
-          Post: {
-            fields: {
-              title: text(),
-            },
-          },
-        },
-      }
-
-      const prismaPath = path.join(tempDir, 'prisma', 'schema.prisma')
-
-      // Generate first config
-      writePrismaSchema(config1, prismaPath)
-      let schema = fs.readFileSync(prismaPath, 'utf-8')
-      expect(schema).toMatchSnapshot('overwrite-before')
-
-      // Generate second config (should overwrite)
-      writePrismaSchema(config2, prismaPath)
-      schema = fs.readFileSync(prismaPath, 'utf-8')
-      expect(schema).toMatchSnapshot('overwrite-after')
-    })
-
-    it('should handle custom opensaasPath', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          prismaClientConstructor: (() => null) as any,
-        },
-        opensaasPath: '.custom',
-        lists: {},
-      }
-
-      const typesPath = path.join(tempDir, '.custom', 'types.ts')
-      const contextPath = path.join(tempDir, '.custom', 'context.ts')
-
-      writeTypes(config, typesPath)
-      writeContext(config, contextPath)
-
-      expect(fs.existsSync(path.join(tempDir, '.custom'))).toBe(true)
-      expect(fs.existsSync(typesPath)).toBe(true)
-      expect(fs.existsSync(contextPath)).toBe(true)
-    })
-
-    it('should generate consistent output across multiple runs', () => {
-      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 prismaPath = path.join(tempDir, 'prisma', 'schema.prisma')
-
-      // Generate twice
-      writePrismaSchema(config, prismaPath)
-      const schema1 = fs.readFileSync(prismaPath, 'utf-8')
-
-      writePrismaSchema(config, prismaPath)
-      const schema2 = fs.readFileSync(prismaPath, 'utf-8')
-
-      // Should be identical
-      expect(schema1).toBe(schema2)
-      expect(schema1).toMatchSnapshot('consistent-output')
-    })
-
-    it('should handle empty lists config', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          prismaClientConstructor: (() => null) as any,
-        },
-        lists: {},
-      }
-
-      const prismaPath = path.join(tempDir, 'prisma', 'schema.prisma')
-      const typesPath = path.join(tempDir, '.opensaas', 'types.ts')
-
-      writePrismaSchema(config, prismaPath)
-      writeTypes(config, typesPath)
-
-      expect(fs.existsSync(prismaPath)).toBe(true)
-      expect(fs.existsSync(typesPath)).toBe(true)
-
-      const schema = fs.readFileSync(prismaPath, 'utf-8')
-      expect(schema).toMatchSnapshot('empty-lists-schema')
-
-      const types = fs.readFileSync(typesPath, 'utf-8')
-      expect(types).toMatchSnapshot('empty-lists-types')
-    })
-
-    it('should handle different database providers', () => {
-      const providers = ['sqlite', 'postgresql', 'mysql'] as const
-
-      providers.forEach((provider) => {
-        const config: OpenSaasConfig = {
-          db: {
-            provider,
-            url: provider === 'sqlite' ? 'file:./dev.db' : 'postgresql://localhost:5432/db',
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            prismaClientConstructor: (() => null) as any,
-          },
-          lists: {},
-        }
-
-        const prismaPath = path.join(tempDir, `${provider}-schema.prisma`)
-        writePrismaSchema(config, prismaPath)
-
-        const schema = fs.readFileSync(prismaPath, 'utf-8')
-        expect(schema).toMatchSnapshot(`${provider}-provider`)
-      })
-    })
-
-    it('should generate files in correct locations', () => {
-      const config: OpenSaasConfig = {
-        db: {
-          provider: 'sqlite',
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          prismaClientConstructor: (() => null) as any,
-        },
-        lists: {
-          User: {
-            fields: {
-              name: text(),
-            },
-          },
-        },
-      }
-
-      writePrismaSchema(config, path.join(tempDir, 'prisma', 'schema.prisma'))
-      writeTypes(config, path.join(tempDir, '.opensaas', 'types.ts'))
-      writeContext(config, path.join(tempDir, '.opensaas', 'context.ts'))
-
-      // Verify directory structure
-      const prismaDir = path.join(tempDir, 'prisma')
-      const opensaasDir = path.join(tempDir, '.opensaas')
-
-      expect(fs.existsSync(prismaDir)).toBe(true)
-      expect(fs.existsSync(opensaasDir)).toBe(true)
-      expect(fs.readdirSync(prismaDir)).toContain('schema.prisma')
-      expect(fs.readdirSync(opensaasDir)).toContain('types.ts')
-      expect(fs.readdirSync(opensaasDir)).toContain('context.ts')
-    })
-  })
-})