@risingwave/wavelet-cli 0.2.1 → 0.2.5

package/package.json

@@ -1,17 +1,30 @@
 {
   "name": "@risingwave/wavelet-cli",
-  "version": "0.2.1",
+  "version": "0.2.5",
   "description": "Wavelet CLI - manage views, generate types, run dev server",
+  "homepage": "https://github.com/risingwavelabs/wavelet",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/risingwavelabs/wavelet.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/risingwavelabs/wavelet/issues"
+  },
   "bin": {
-    "wavelet": "./dist/index.js"
+    "wavelet": "dist/index.js"
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsc",
-    "dev": "tsx src/index.ts"
+    "dev": "tsx src/index.ts",
+    "prepack": "npm --prefix ../config run build && npm --prefix ../server run build && npm run build"
   },
   "dependencies": {
-    "@risingwave/wavelet": "0.2.1",
-    "@risingwave/wavelet-server": "0.2.1",
+    "@risingwave/wavelet": "0.2.5",
+    "@risingwave/wavelet-server": "0.2.5",
     "pg": "^8.13.0",
     "tsx": "^4.0.0"
   },

package/src/codegen.ts

@@ -1,214 +0,0 @@
-import { writeFileSync, mkdirSync } from 'node:fs'
-import pg from 'pg'
-import type { WaveletConfig, SqlFragment, QueryDef, ColumnType } from '@risingwave/wavelet'
-
-const { Client } = pg
-
-export async function generateClient(config: WaveletConfig): Promise<void> {
-  // Event types are always known from config
-  const eventTypes: TypedEntity[] = []
-  const events = config.events ?? config.streams ?? {}
-  for (const [eventName, eventDef] of Object.entries(events)) {
-    const columns = Object.entries(eventDef.columns).map(([name, type]) => ({
-      name,
-      tsType: columnTypeToTs(type),
-    }))
-    eventTypes.push({ name: eventName, columns })
-  }
-
-  // Query types: try config-declared columns first, then RisingWave introspection, then generic
-  const queryTypes: TypedEntity[] = []
-  let dbClient: InstanceType<typeof Client> | null = null
-  const queries = config.queries ?? config.views ?? {}
-
-  for (const [queryName, queryDef] of Object.entries(queries)) {
-    // Tier 1: explicit columns in config
-    const declaredColumns = getQueryColumns(queryDef)
-    if (declaredColumns) {
-      queryTypes.push({ name: queryName, columns: declaredColumns })
-      continue
-    }
-
-    // Tier 2: introspect from RisingWave (if reachable)
-    if (!dbClient) {
-      dbClient = await tryConnect(config.database)
-    }
-
-    if (dbClient) {
-      try {
-        const result = await dbClient.query(
-          `SELECT column_name, data_type FROM information_schema.columns WHERE table_name = $1 ORDER BY ordinal_position`,
-          [queryName]
-        )
-        if (result.rows.length > 0) {
-          queryTypes.push({
-            name: queryName,
-            columns: result.rows.map((row: any) => ({
-              name: row.column_name,
-              tsType: pgTypeToTs(row.data_type),
-            })),
-          })
-          continue
-        }
-      } catch {
-        // Fall through to tier 3
-      }
-    }
-
-    // Tier 3: generic fallback
-    queryTypes.push({ name: queryName, columns: [] })
-  }
-
-  if (dbClient) {
-    await dbClient.end().catch(() => {})
-  }
-
-  const code = generateCode(queryTypes, eventTypes)
-
-  mkdirSync('.wavelet', { recursive: true })
-  writeFileSync('.wavelet/client.ts', code)
-}
-
-interface TypedEntity {
-  name: string
-  columns: { name: string; tsType: string }[]
-}
-
-function getQueryColumns(queryDef: QueryDef | SqlFragment): { name: string; tsType: string }[] | null {
-  // SqlFragment has no columns
-  if ('_tag' in queryDef && queryDef._tag === 'sql') return null
-
-  // QueryDef might have explicit columns
-  const qd = queryDef as QueryDef
-  if (!qd.columns) return null
-
-  return Object.entries(qd.columns).map(([name, type]) => ({
-    name,
-    tsType: columnTypeToTs(type),
-  }))
-}
-
-async function tryConnect(connectionString: string): Promise<InstanceType<typeof Client> | null> {
-  const client = new Client({ connectionString, connectionTimeoutMillis: 3000 })
-  try {
-    await client.connect()
-    return client
-  } catch {
-    return null
-  }
-}
-
-function generateCode(queries: TypedEntity[], events: TypedEntity[]): string {
-  let code = `// Auto-generated by wavelet generate - do not edit\n`
-  code += `// Run 'npx wavelet generate' to regenerate\n\n`
-  code += `import { WaveletClient } from '@risingwave/wavelet-sdk'\n`
-  code += `import type { QueryHandle, EventHandle, Diff, WaveletClientOptions } from '@risingwave/wavelet-sdk'\n\n`
-
-  // Query row types
-  for (const q of queries) {
-    const typeName = pascalCase(q.name) + 'Row'
-    if (q.columns.length > 0) {
-      code += `export interface ${typeName} {\n`
-      for (const col of q.columns) {
-        code += `  ${col.name}: ${col.tsType}\n`
-      }
-      code += `}\n\n`
-    } else {
-      code += `export type ${typeName} = Record<string, unknown>\n\n`
-    }
-  }
-
-  // Event types
-  for (const ev of events) {
-    const typeName = pascalCase(ev.name) + 'Event'
-    code += `export interface ${typeName} {\n`
-    for (const col of ev.columns) {
-      code += `  ${col.name}: ${col.tsType}\n`
-    }
-    code += `}\n\n`
-  }
-
-  // Typed client class
-  code += `export class TypedWaveletClient {\n`
-  code += `  private client: WaveletClient\n\n`
-  code += `  constructor(options: WaveletClientOptions) {\n`
-  code += `    this.client = new WaveletClient(options)\n`
-  code += `  }\n\n`
-
-  // Query accessors
-  code += `  queries = {\n`
-  for (const q of queries) {
-    const typeName = pascalCase(q.name) + 'Row'
-    code += `    ${q.name}: this.client.query<${typeName}>('${q.name}'),\n`
-  }
-  code += `  }\n\n`
-
-  // Event accessors
-  code += `  events = {\n`
-  for (const ev of events) {
-    const typeName = pascalCase(ev.name) + 'Event'
-    code += `    ${ev.name}: this.client.event<${typeName}>('${ev.name}'),\n`
-  }
-  code += `  }\n`
-  code += `}\n\n`
-
-  // Query name literal type
-  const queryNames = queries.map(q => `'${q.name}'`).join(' | ')
-  code += `export type QueryName = ${queryNames || 'never'}\n\n`
-
-  // React hook overloads
-  code += `// React hook overloads for type-safe useWavelet\n`
-  code += `import type { UseWaveletResult } from '@risingwave/wavelet-sdk/react'\n\n`
-  for (const q of queries) {
-    const typeName = pascalCase(q.name) + 'Row'
-    code += `export declare function useWavelet(query: '${q.name}'): UseWaveletResult<${typeName}>\n`
-  }
-
-  return code
-}
-
-function pgTypeToTs(pgType: string): string {
-  switch (pgType.toLowerCase()) {
-    case 'integer':
-    case 'bigint':
-    case 'smallint':
-    case 'real':
-    case 'double precision':
-    case 'numeric':
-    case 'float':
-    case 'int':
-      return 'number'
-    case 'boolean':
-      return 'boolean'
-    case 'jsonb':
-    case 'json':
-      return 'unknown'
-    case 'timestamp with time zone':
-    case 'timestamp without time zone':
-    case 'timestamptz':
-      return 'string'
-    default:
-      return 'string'
-  }
-}
-
-function columnTypeToTs(colType: string): string {
-  switch (colType) {
-    case 'int':
-    case 'float':
-      return 'number'
-    case 'boolean':
-      return 'boolean'
-    case 'json':
-      return 'unknown'
-    default:
-      return 'string'
-  }
-}
-
-function pascalCase(str: string): string {
-  return str
-    .split(/[_\s-]+/)
-    .map(s => s.charAt(0).toUpperCase() + s.slice(1))
-    .join('')
-}

package/src/config-loader.ts

@@ -1,69 +0,0 @@
-import { resolve } from 'node:path'
-import { execSync } from 'node:child_process'
-import type { WaveletConfig } from '@risingwave/wavelet'
-
-export async function loadConfig(configPath: string): Promise<WaveletConfig> {
-  const abs = resolve(configPath)
-
-  // For .ts files, use tsx to evaluate the config
-  if (abs.endsWith('.ts')) {
-    return loadTsConfig(abs)
-  }
-
-  // For .js/.mjs files, use dynamic import directly
-  const { pathToFileURL } = await import('node:url')
-  const mod = await import(pathToFileURL(abs).href)
-  return unwrapConfig(mod)
-}
-
-function loadTsConfig(absPath: string): WaveletConfig {
-  // Use tsx to evaluate the TypeScript config and extract the result as JSON
-  const script = `
-    import('${absPath}').then(mod => {
-      let config = mod.default ?? mod;
-      if (config && typeof config === 'object' && 'default' in config) config = config.default;
-      process.stdout.write(JSON.stringify(config));
-    }).catch(err => {
-      process.stderr.write(err.message);
-      process.exit(1);
-    });
-  `
-
-  try {
-    const result = execSync(`npx tsx -e "${script.replace(/"/g, '\\"')}"`, {
-      cwd: resolve(absPath, '..'),
-      encoding: 'utf-8',
-      timeout: 15000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    })
-    const config = JSON.parse(result)
-    if (!config || !config.database) {
-      throw new Error('Config missing database field')
-    }
-    return config
-  } catch (err: any) {
-    throw new Error(
-      `Failed to load ${absPath}.\n` +
-      `Make sure tsx is installed: npm install tsx\n` +
-      `Error: ${err.stderr || err.message}`
-    )
-  }
-}
-
-function unwrapConfig(mod: any): WaveletConfig {
-  let config = mod.default ?? mod
-  if (config && typeof config === 'object' && 'default' in config) {
-    config = config.default
-  }
-
-  if (!config || !config.database) {
-    throw new Error(
-      `wavelet.config.ts must export a config with a 'database' field.\n` +
-      `Example:\n` +
-      `  import { defineConfig } from '@risingwave/wavelet'\n` +
-      `  export default defineConfig({ database: 'postgres://...' })`
-    )
-  }
-
-  return config
-}

package/src/index.ts

@@ -1,233 +0,0 @@
-#!/usr/bin/env node
-
-const command = process.argv[2]
-
-const HELP = `
-wavelet - Subscribe to computed results, not raw rows.
-
-Usage:
-  wavelet <command> [options]
-
-Commands:
-  dev        Start local development server
-  generate   Generate typed client from query definitions
-  push       Sync query definitions to Wavelet server
-  status     Show current configuration and connection status
-  init       Initialize a new Wavelet project
-
-Options:
-  --config   Path to wavelet.config.ts (default: ./wavelet.config.ts)
-  --json     Output in JSON format
-  --help     Show this help message
-
-Examples:
-  wavelet init
-  wavelet dev
-  wavelet generate
-  wavelet push
-`
-
-async function main() {
-  switch (command) {
-    case 'init':
-      await runInit()
-      break
-    case 'dev':
-      await runDev()
-      break
-    case 'generate':
-      await runGenerate()
-      break
-    case 'push':
-      await runPush()
-      break
-    case 'status':
-      await runStatus()
-      break
-    case '--help':
-    case '-h':
-    case undefined:
-      console.log(HELP)
-      break
-    default:
-      console.error(`Unknown command: '${command}'`)
-      console.error(`Run 'wavelet --help' for available commands.`)
-      process.exit(1)
-  }
-}
-
-async function runInit() {
-  const { writeFileSync, existsSync } = await import('node:fs')
-
-  if (existsSync('wavelet.config.ts')) {
-    console.log('wavelet.config.ts already exists. Skipping.')
-    return
-  }
-
-  writeFileSync('wavelet.config.ts', `import { defineConfig, sql } from '@risingwave/wavelet'
-
-export default defineConfig({
-  database: process.env.WAVELET_DATABASE_URL ?? 'postgres://root@localhost:4566/dev',
-
-  events: {
-    // Define your events here
-    // game_events: {
-    //   columns: {
-    //     user_id: 'string',
-    //     action: 'string',
-    //     value: 'int',
-    //   }
-    // }
-  },
-
-  queries: {
-    // Define your queries (materialized views) here
-    // leaderboard: sql\`
-    //   SELECT user_id, SUM(value) as total
-    //   FROM game_events
-    //   GROUP BY user_id
-    //   ORDER BY total DESC
-    //   LIMIT 100
-    // \`,
-  },
-})
-`)
-
-  console.log('Created wavelet.config.ts')
-  console.log('')
-  console.log('Next steps:')
-  console.log('  1. Edit wavelet.config.ts to define your events and queries')
-  console.log('  2. Run: wavelet dev')
-}
-
-async function runDev() {
-  const { loadConfig } = await import('./config-loader.js')
-  const { ensureRisingWave } = await import('./risingwave-launcher.js')
-  const configPath = getConfigPath()
-
-  console.log(`Loading config from ${configPath}...`)
-  const config = await loadConfig(configPath)
-
-  // Ensure RisingWave is running
-  const rwProcess = await ensureRisingWave(config.database)
-
-  // Sync DDL before starting server
-  const { DdlManager, WaveletServer } = await import('@risingwave/wavelet-server')
-  const ddl = new DdlManager(config.database)
-  await ddl.connect()
-
-  console.log('\nSyncing events and queries...')
-  const actions = await ddl.sync(config)
-  printDdlActions(actions)
-  await ddl.close()
-
-  // Start server
-  const server = new WaveletServer(config)
-  await server.start()
-
-  const shutdown = async () => {
-    console.log('\nShutting down...')
-    await server.stop()
-    if (rwProcess) {
-      console.log('Stopping RisingWave...')
-      rwProcess.kill()
-    }
-    process.exit(0)
-  }
-  process.on('SIGINT', shutdown)
-  process.on('SIGTERM', shutdown)
-}
-
-async function runGenerate() {
-  const { loadConfig } = await import('./config-loader.js')
-  const { generateClient } = await import('./codegen.js')
-  const configPath = getConfigPath()
-
-  console.log(`Loading config from ${configPath}...`)
-  const config = await loadConfig(configPath)
-
-  await generateClient(config)
-  console.log('Generated .wavelet/client.ts')
-}
-
-async function runPush() {
-  const { loadConfig } = await import('./config-loader.js')
-  const configPath = getConfigPath()
-
-  console.log(`Loading config from ${configPath}...`)
-  const config = await loadConfig(configPath)
-
-  const { DdlManager } = await import('@risingwave/wavelet-server')
-  const ddl = new DdlManager(config.database)
-  await ddl.connect()
-
-  const actions = await ddl.sync(config)
-  await ddl.close()
-
-  const isJson = process.argv.includes('--json')
-  if (isJson) {
-    console.log(JSON.stringify({ actions }))
-  } else {
-    printDdlActions(actions)
-  }
-}
-
-async function runStatus() {
-  const { loadConfig } = await import('./config-loader.js')
-  const configPath = getConfigPath()
-
-  try {
-    const config = await loadConfig(configPath)
-    const eventCount = Object.keys(config.events ?? config.streams ?? {}).length
-    const queryCount = Object.keys(config.queries ?? config.views ?? {}).length
-
-    console.log(`Config:   ${configPath}`)
-    console.log(`Database: ${config.database.replace(/\/\/[^@]+@/, '//***@')}`)
-    console.log(`Events:   ${eventCount}`)
-    console.log(`Queries:  ${queryCount}`)
-
-    if (queryCount > 0) {
-      console.log('\nQueries:')
-      for (const name of Object.keys(config.queries ?? config.views ?? {})) {
-        console.log(`  - ${name}`)
-      }
-    }
-  } catch (err: any) {
-    console.error(`Error: ${err.message}`)
-    process.exit(1)
-  }
-}
-
-function printDdlActions(actions: { type: string; resource: string; name: string; detail?: string }[]): void {
-  const changed = actions.filter(a => a.type !== 'unchanged')
-  const unchanged = actions.filter(a => a.type === 'unchanged')
-
-  for (const action of actions) {
-    const icon = action.type === 'create' ? '+' : action.type === 'delete' ? '-' : ' '
-    const label = `${action.resource} '${action.name}'`
-    const detail = action.detail ? ` (${action.detail})` : ''
-
-    if (action.type === 'unchanged') {
-      console.log(`  ${icon} ${label}`)
-    } else if (action.type === 'create') {
-      console.log(`  ${icon} ${label} - created${detail}`)
-    } else if (action.type === 'delete') {
-      console.log(`  ${icon} ${label} - removed${detail}`)
-    }
-  }
-
-  console.log(`\n${changed.length} changed, ${unchanged.length} unchanged`)
-}
-
-function getConfigPath(): string {
-  const idx = process.argv.indexOf('--config')
-  if (idx !== -1 && process.argv[idx + 1]) {
-    return process.argv[idx + 1]
-  }
-  return './wavelet.config.ts'
-}
-
-main().catch((err) => {
-  console.error('Error:', err.message)
-  process.exit(1)
-})

package/src/risingwave-launcher.ts

@@ -1,177 +0,0 @@
-import { execSync, spawn, type ChildProcess } from 'node:child_process'
-import pg from 'pg'
-
-const { Client } = pg
-
-export async function ensureRisingWave(connectionString: string): Promise<ChildProcess | null> {
-  // Try to connect to existing RisingWave
-  if (await isReachable(connectionString)) {
-    console.log('RisingWave is already running.')
-    return null
-  }
-
-  console.log('RisingWave is not reachable. Attempting to start...')
-
-  // Try native binary first, then docker
-  const binary = findBinary()
-  if (binary) {
-    return startNative(binary)
-  }
-
-  if (hasDocker()) {
-    return startDocker()
-  }
-
-  console.error(
-    'Could not start RisingWave.\n\n' +
-    'Install one of:\n' +
-    '  brew tap risingwavelabs/risingwave && brew install risingwave\n' +
-    '  docker pull risingwavelabs/risingwave:latest\n\n' +
-    'Or start RisingWave manually and re-run wavelet dev.'
-  )
-  process.exit(1)
-}
-
-async function isReachable(connectionString: string): Promise<boolean> {
-  const client = new Client({ connectionString, connectionTimeoutMillis: 3000 })
-  try {
-    await client.connect()
-    await client.query('SELECT 1')
-    await client.end()
-    return true
-  } catch {
-    return false
-  }
-}
-
-function findBinary(): string | null {
-  try {
-    const path = execSync('which risingwave', { encoding: 'utf-8' }).trim()
-    return path || null
-  } catch {
-    return null
-  }
-}
-
-function hasDocker(): boolean {
-  try {
-    execSync('docker info', { stdio: 'ignore' })
-    return true
-  } catch {
-    return false
-  }
-}
-
-function startNative(binaryPath: string): Promise<ChildProcess> {
-  return new Promise((resolve, reject) => {
-    console.log(`Starting RisingWave (${binaryPath})...`)
-    const child = spawn(binaryPath, ['playground'], {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      detached: false,
-    })
-
-    let started = false
-
-    const onData = (data: Buffer) => {
-      const text = data.toString()
-      if (!started && text.includes('ready to accept connections')) {
-        started = true
-        console.log('RisingWave started (playground mode).')
-        resolve(child)
-      }
-    }
-
-    child.stdout?.on('data', onData)
-    child.stderr?.on('data', onData)
-
-    child.on('error', (err) => {
-      if (!started) reject(err)
-    })
-
-    child.on('exit', (code) => {
-      if (!started) reject(new Error(`RisingWave exited with code ${code}`))
-    })
-
-    // Fallback: poll for connectivity
-    const poll = setInterval(async () => {
-      if (started) {
-        clearInterval(poll)
-        return
-      }
-      if (await isReachable('postgres://root@localhost:4566/dev')) {
-        started = true
-        clearInterval(poll)
-        console.log('RisingWave started (playground mode).')
-        resolve(child)
-      }
-    }, 1000)
-
-    // Timeout after 30 seconds
-    setTimeout(() => {
-      if (!started) {
-        clearInterval(poll)
-        child.kill()
-        reject(new Error('RisingWave failed to start within 30 seconds.'))
-      }
-    }, 30000)
-  })
-}
-
-function startDocker(): Promise<ChildProcess> {
-  return new Promise((resolve, reject) => {
-    console.log('Starting RisingWave via Docker...')
-
-    // Remove stale container if exists
-    try {
-      execSync('docker rm -f wavelet-risingwave', { stdio: 'ignore' })
-    } catch {}
-
-    const child = spawn('docker', [
-      'run', '--name', 'wavelet-risingwave',
-      '-p', '4566:4566',
-      'risingwavelabs/risingwave:latest',
-      'playground',
-    ], {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      detached: false,
-    })
-
-    let started = false
-
-    // Poll for connectivity
-    const poll = setInterval(async () => {
-      if (started) {
-        clearInterval(poll)
-        return
-      }
-      if (await isReachable('postgres://root@localhost:4566/dev')) {
-        started = true
-        clearInterval(poll)
-        console.log('RisingWave started via Docker.')
-        resolve(child)
-      }
-    }, 1000)
-
-    child.on('error', (err) => {
-      if (!started) {
-        clearInterval(poll)
-        reject(err)
-      }
-    })
-
-    child.on('exit', (code) => {
-      if (!started) {
-        clearInterval(poll)
-        reject(new Error(`Docker exited with code ${code}`))
-      }
-    })
-
-    setTimeout(() => {
-      if (!started) {
-        clearInterval(poll)
-        child.kill()
-        reject(new Error('RisingWave Docker container failed to start within 60 seconds.'))
-      }
-    }, 60000)
-  })
-}

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src"]
-}