@basicbenframework/core 0.1.0

package/src/commands/build.js

@@ -0,0 +1,155 @@
+/**
+ * build command
+ * Builds the client (Vite) and prepares server for production
+ */
+
+import { spawn } from 'node:child_process'
+import { existsSync, mkdirSync, copyFileSync, readdirSync } from 'node:fs'
+import { resolve, join } from 'node:path'
+import { bold, cyan, green, yellow, dim, red } from '../cli/colors.js'
+
+export async function run(args, flags) {
+  const cwd = process.cwd()
+  const staticOnly = flags.static || false
+
+  console.log(`\n${bold('BasicBen')} ${dim('build')}${staticOnly ? dim(' --static') : ''}\n`)
+
+  // Build client with Vite
+  console.log(`${cyan('Building client...')}\n`)
+
+  const outDir = staticOnly ? 'dist' : 'dist/client'
+  const viteBuild = await runViteBuild(cwd, outDir)
+  if (!viteBuild.success) {
+    console.error(`\n${red('Client build failed')}\n`)
+    process.exit(1)
+  }
+
+  console.log(`\n${green('✓')} Client built to ${dim(outDir)}\n`)
+
+  // Static-only build stops here
+  if (staticOnly) {
+    console.log(`${green('Static build complete!')}\n`)
+    console.log(`Deploy the ${cyan('dist/')} folder to any static host (CF Pages, Netlify, etc.)\n`)
+    return
+  }
+
+  // Copy server files to dist
+  console.log(`${cyan('Preparing server...')}\n`)
+
+  await prepareServer(cwd)
+
+  console.log(`${green('✓')} Server prepared in ${dim('dist/server')}\n`)
+
+  // Summary
+  console.log(`${green('Build complete!')}\n`)
+  console.log(`Run ${cyan('basicben start')} to start the production server.\n`)
+}
+
+/**
+ * Run Vite build
+ */
+function runViteBuild(cwd, outDir = 'dist/client') {
+  return new Promise((resolve) => {
+    const proc = spawn('npx', ['vite', 'build', '--outDir', outDir], {
+      cwd,
+      stdio: 'inherit',
+      env: {
+        ...process.env,
+        NODE_ENV: 'production'
+      }
+    })
+
+    proc.on('exit', (code) => {
+      resolve({ success: code === 0 })
+    })
+
+    proc.on('error', () => {
+      resolve({ success: false })
+    })
+  })
+}
+
+/**
+ * Prepare server files for production
+ */
+async function prepareServer(cwd) {
+  const distServer = resolve(cwd, 'dist/server')
+
+  // Create dist/server directory
+  if (!existsSync(distServer)) {
+    mkdirSync(distServer, { recursive: true })
+  }
+
+  // Copy server source files
+  const serverDirs = ['src/server', 'src/routes', 'src/controllers', 'src/models', 'src/middleware']
+
+  for (const dir of serverDirs) {
+    const srcDir = resolve(cwd, dir)
+    if (existsSync(srcDir)) {
+      const destDir = resolve(distServer, dir.replace('src/', ''))
+      copyDir(srcDir, destDir)
+    }
+  }
+
+  // Copy package.json for production dependencies
+  const pkgSrc = resolve(cwd, 'package.json')
+  if (existsSync(pkgSrc)) {
+    copyFileSync(pkgSrc, resolve(distServer, 'package.json'))
+  }
+
+  // Create production server entry
+  const hasCustomServer = existsSync(resolve(cwd, 'src/server/index.js'))
+
+  const serverEntry = hasCustomServer
+    ? `
+import { createServer } from './server/index.js'
+
+const app = await createServer({
+  static: { dir: '../client' }
+})
+
+const port = process.env.PORT || 3000
+
+app.listen(port, () => {
+  console.log(\`Server running at http://localhost:\${port}\`)
+})
+`.trim()
+    : `
+import { createServer } from 'basicben/server'
+
+const app = await createServer({
+  static: { dir: '../client' }
+})
+
+const port = process.env.PORT || 3000
+
+app.listen(port, () => {
+  console.log(\`Server running at http://localhost:\${port}\`)
+})
+`.trim()
+
+  const { writeFileSync } = await import('node:fs')
+  writeFileSync(resolve(distServer, 'index.js'), serverEntry)
+}
+
+/**
+ * Recursively copy directory
+ */
+function copyDir(src, dest) {
+  if (!existsSync(dest)) {
+    mkdirSync(dest, { recursive: true })
+  }
+
+  const entries = readdirSync(src, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name)
+    const destPath = join(dest, entry.name)
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath)
+    } else if (entry.name.endsWith('.js') && !entry.name.endsWith('.test.js')) {
+      copyFileSync(srcPath, destPath)
+    }
+  }
+}

package/src/commands/dev.js

@@ -0,0 +1,206 @@
+/**
+ * dev command
+ * Starts Vite dev server (port 3000) and Node API server (port 3001)
+ * Vite proxies /api/* requests to Node
+ */
+
+import { spawn } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { resolve, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { bold, cyan, green, yellow, dim, red } from '../cli/colors.js'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+/**
+ * Load .env file into process.env
+ */
+function loadEnv(cwd) {
+  const envPath = resolve(cwd, '.env')
+  if (!existsSync(envPath)) return
+
+  const content = readFileSync(envPath, 'utf-8')
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith('#')) continue
+    const [key, ...rest] = trimmed.split('=')
+    if (key && rest.length) {
+      let value = rest.join('=').trim()
+      // Strip inline comments (but not if inside quotes)
+      if (!value.startsWith('"') && !value.startsWith("'")) {
+        const commentIndex = value.indexOf('#')
+        if (commentIndex !== -1) {
+          value = value.substring(0, commentIndex).trim()
+        }
+      }
+      process.env[key.trim()] = value
+    }
+  }
+}
+
+export async function run(args, flags) {
+  const cwd = process.cwd()
+
+  // Load .env file
+  loadEnv(cwd)
+
+  console.log(`\n${bold('BasicBen')} ${dim('dev')}\n`)
+
+  // Find server entry (uses framework default if no custom server)
+  const serverEntry = findServerEntry(cwd)
+
+  const viteConfig = findViteConfig(cwd)
+
+  // Start Node server with --watch
+  const nodePort = flags.port || process.env.PORT || 3001
+  const nodeProcess = startNodeServer(serverEntry, nodePort, cwd)
+
+  // Start Vite dev server
+  const vitePort = flags.vitePort || process.env.VITE_PORT || 3000
+  const viteProcess = startViteServer(vitePort, nodePort, viteConfig, cwd)
+
+  // Handle process cleanup
+  const cleanup = () => {
+    console.log(`\n${dim('Shutting down...')}\n`)
+    nodeProcess.kill()
+    viteProcess.kill()
+    process.exit(0)
+  }
+
+  process.on('SIGINT', cleanup)
+  process.on('SIGTERM', cleanup)
+
+  // Wait for both processes
+  nodeProcess.on('exit', (code) => {
+    if (code !== 0 && code !== null) {
+      console.error(`${red('Node server exited with code')} ${code}`)
+    }
+  })
+
+  viteProcess.on('exit', (code) => {
+    if (code !== 0 && code !== null) {
+      console.error(`${red('Vite exited with code')} ${code}`)
+    }
+    cleanup()
+  })
+}
+
+/**
+ * Find server entry point
+ * Returns default framework entry if no custom server exists
+ */
+function findServerEntry(cwd) {
+  const candidates = [
+    'src/server/index.js',
+    'src/server.js',
+    'src/index.js',
+    'server/index.js',
+    'server.js'
+  ]
+
+  for (const candidate of candidates) {
+    const fullPath = resolve(cwd, candidate)
+    if (existsSync(fullPath)) {
+      return fullPath
+    }
+  }
+
+  // No custom server found, use framework default
+  return resolve(__dirname, '../server/default-entry.js')
+}
+
+/**
+ * Find Vite config
+ */
+function findViteConfig(cwd) {
+  const candidates = [
+    'vite.config.js',
+    'vite.config.ts',
+    'vite.config.mjs'
+  ]
+
+  for (const candidate of candidates) {
+    const fullPath = resolve(cwd, candidate)
+    if (existsSync(fullPath)) {
+      return fullPath
+    }
+  }
+
+  return null
+}
+
+/**
+ * Start Node server with --watch flag
+ */
+function startNodeServer(entry, port, cwd) {
+  console.log(`${cyan('API')}    ${dim('→')} http://localhost:${port}`)
+
+  const nodeArgs = [
+    '--watch',
+    '--env-file=.env'
+  ]
+
+  // Add .env file if it exists
+  if (!existsSync(resolve(cwd, '.env'))) {
+    nodeArgs.splice(1, 1) // Remove --env-file if no .env
+  }
+
+  nodeArgs.push(entry)
+
+  const proc = spawn('node', nodeArgs, {
+    cwd,
+    stdio: ['inherit', 'pipe', 'pipe'],
+    env: {
+      ...process.env,
+      PORT: port,
+      NODE_ENV: 'development'
+    }
+  })
+
+  // Prefix output with [API]
+  proc.stdout?.on('data', (data) => {
+    const lines = data.toString().trim().split('\n')
+    for (const line of lines) {
+      if (line) console.log(`${dim('[API]')} ${line}`)
+    }
+  })
+
+  proc.stderr?.on('data', (data) => {
+    const lines = data.toString().trim().split('\n')
+    for (const line of lines) {
+      if (line) console.error(`${dim('[API]')} ${line}`)
+    }
+  })
+
+  return proc
+}
+
+/**
+ * Start Vite dev server with proxy config
+ */
+function startViteServer(port, apiPort, configPath, cwd) {
+  console.log(`${green('Vite')}   ${dim('→')} http://localhost:${port}`)
+  console.log()
+
+  const viteArgs = [
+    'vite',
+    '--port', String(port),
+    '--strictPort'
+  ]
+
+  if (configPath) {
+    viteArgs.push('--config', configPath)
+  }
+
+  const proc = spawn('npx', viteArgs, {
+    cwd,
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      PORT: apiPort,
+      NODE_ENV: 'development'
+    }
+  })
+
+  return proc
+}

package/src/commands/help.js

@@ -0,0 +1,84 @@
+/**
+ * Help command. Shows available commands and usage.
+ */
+
+import { bold, cyan, dim, yellow } from '../cli/colors.js'
+import { commandMeta } from '../cli/dispatcher.js'
+
+export async function run(args, flags) {
+  const specificCommand = args[0]
+
+  if (specificCommand) {
+    showCommandHelp(specificCommand)
+  } else {
+    showGeneralHelp()
+  }
+}
+
+function showGeneralHelp() {
+  console.log(`
+${bold('BasicBen')} — A full-stack framework for React
+
+${bold('Usage:')}
+  basicben <command> [options]
+
+${bold('Development')}
+  ${cyan('dev')}                Start Vite + Node dev server
+  ${cyan('build')}              Build for production
+  ${cyan('start')}              Start production server
+  ${cyan('test')}               Run tests with Vitest
+
+${bold('Scaffolding')}
+  ${cyan('make:controller')}    Generate a controller
+  ${cyan('make:model')}         Generate a model
+  ${cyan('make:route')}         Generate a route file
+  ${cyan('make:migration')}     Generate a migration file
+  ${cyan('make:middleware')}    Generate middleware
+
+${bold('Database')}
+  ${cyan('migrate')}            Run pending migrations
+  ${cyan('migrate:rollback')}   Roll back last batch
+  ${cyan('migrate:fresh')}      Drop all and re-run
+  ${cyan('migrate:status')}     Show migration status
+
+${bold('Options')}
+  ${cyan('--help, -h')}         Show help
+  ${cyan('--version, -v')}      Show version
+
+Run ${cyan('basicben help <command>')} for details on a specific command.
+`)
+}
+
+function showCommandHelp(command) {
+  const meta = commandMeta[command]
+
+  if (!meta) {
+    console.log(`\n${yellow('Unknown command:')} ${command}`)
+    console.log(`Run ${cyan('basicben help')} to see available commands.\n`)
+    return
+  }
+
+  console.log(`
+${bold('Command:')} ${cyan(command)}
+
+${meta.description}
+
+${bold('Usage:')}
+  ${meta.usage}
+`)
+
+  // Add command-specific options if available
+  if (meta.options) {
+    console.log(`${bold('Options:')}`)
+    for (const [flag, desc] of Object.entries(meta.options)) {
+      console.log(`  ${cyan(flag)}  ${desc}`)
+    }
+    console.log()
+  }
+
+  // Add example if available
+  if (meta.example) {
+    console.log(`${bold('Example:')}`)
+    console.log(`  ${dim('$')} ${meta.example}\n`)
+  }
+}

package/src/commands/make-controller.js

@@ -0,0 +1,36 @@
+/**
+ * make:controller command
+ * Generates a controller file in src/controllers/
+ */
+
+import { generate, transformName } from '../scaffolding/index.js'
+import { green, red, cyan, dim } from '../cli/colors.js'
+
+export async function run(args, flags) {
+  const name = args[0]
+
+  if (!name) {
+    console.error(`\n${red('Error:')} Controller name is required`)
+    console.error(`\nUsage: ${cyan('basicben make:controller <Name>')}\n`)
+    process.exit(1)
+  }
+
+  const names = transformName(name)
+  const fileName = `${names.pascal}Controller.js`
+  const targetPath = `src/controllers/${fileName}`
+
+  try {
+    const fullPath = generate('controller', targetPath, {
+      Name: names.pascal,
+      name: names.camel,
+      lower: names.lower,
+      pluralLower: names.pluralLower
+    })
+
+    console.log(`\n${green('Created:')} ${targetPath}`)
+    console.log(`${dim('Controller:')} ${names.pascal}Controller\n`)
+  } catch (err) {
+    console.error(`\n${red('Error:')} ${err.message}\n`)
+    process.exit(1)
+  }
+}

package/src/commands/make-middleware.js

@@ -0,0 +1,44 @@
+/**
+ * make:middleware command
+ * Generates a middleware file in src/middleware/
+ */
+
+import { generate, transformName } from '../scaffolding/index.js'
+import { green, red, cyan, dim } from '../cli/colors.js'
+
+export async function run(args, flags) {
+  const name = args[0]
+
+  if (!name) {
+    console.error(`\n${red('Error:')} Middleware name is required`)
+    console.error(`\nUsage: ${cyan('basicben make:middleware <name>')}\n`)
+    process.exit(1)
+  }
+
+  const names = transformName(name)
+  const fileName = `${names.lower}.js`
+  const targetPath = `src/middleware/${fileName}`
+
+  // Use auth stub for 'auth' middleware, otherwise use generic stub
+  const stubName = names.lower === 'auth' ? 'middleware-auth' : 'middleware'
+
+  try {
+    const fullPath = generate(stubName, targetPath, {
+      Name: names.pascal,
+      name: names.camel,
+      lower: names.lower
+    })
+
+    console.log(`\n${green('Created:')} ${targetPath}`)
+
+    if (names.lower === 'auth') {
+      console.log(`${dim('JWT auth middleware generated')}`)
+      console.log(`${dim('Requires APP_KEY in .env')}\n`)
+    } else {
+      console.log()
+    }
+  } catch (err) {
+    console.error(`\n${red('Error:')} ${err.message}\n`)
+    process.exit(1)
+  }
+}

package/src/commands/make-migration.js

@@ -0,0 +1,51 @@
+/**
+ * make:migration command
+ * Generates a migration file in migrations/
+ */
+
+import { generate, transformName, timestamp } from '../scaffolding/index.js'
+import { green, red, cyan, dim } from '../cli/colors.js'
+
+export async function run(args, flags) {
+  const name = args[0]
+
+  if (!name) {
+    console.error(`\n${red('Error:')} Migration name is required`)
+    console.error(`\nUsage: ${cyan('basicben make:migration <name>')}\n`)
+    console.error(`Examples:`)
+    console.error(`  ${dim('basicben make:migration create_users')}`)
+    console.error(`  ${dim('basicben make:migration add_email_to_users')}\n`)
+    process.exit(1)
+  }
+
+  const ts = timestamp()
+  const names = transformName(name)
+
+  // Extract table name from migration name
+  // create_users -> users
+  // add_email_to_users -> users
+  let tableName = names.snake
+  if (tableName.startsWith('create_')) {
+    tableName = tableName.replace('create_', '')
+  } else if (tableName.includes('_to_')) {
+    tableName = tableName.split('_to_').pop()
+  } else if (tableName.includes('_from_')) {
+    tableName = tableName.split('_from_').pop()
+  }
+
+  const fileName = `${ts}_${names.snake}.js`
+  const targetPath = `migrations/${fileName}`
+
+  try {
+    const fullPath = generate('migration', targetPath, {
+      description: name.replace(/_/g, ' '),
+      tableName: tableName
+    })
+
+    console.log(`\n${green('Created:')} ${targetPath}`)
+    console.log(`${dim('Table:')} ${tableName}\n`)
+  } catch (err) {
+    console.error(`\n${red('Error:')} ${err.message}\n`)
+    process.exit(1)
+  }
+}

package/src/commands/make-model.js

@@ -0,0 +1,38 @@
+/**
+ * make:model command
+ * Generates a model file in src/models/
+ */
+
+import { generate, transformName } from '../scaffolding/index.js'
+import { green, red, cyan, dim } from '../cli/colors.js'
+
+export async function run(args, flags) {
+  const name = args[0]
+
+  if (!name) {
+    console.error(`\n${red('Error:')} Model name is required`)
+    console.error(`\nUsage: ${cyan('basicben make:model <Name>')}\n`)
+    process.exit(1)
+  }
+
+  const names = transformName(name)
+  const fileName = `${names.pascal}.js`
+  const targetPath = `src/models/${fileName}`
+
+  try {
+    const fullPath = generate('model', targetPath, {
+      Name: names.pascal,
+      name: names.camel,
+      lower: names.lower,
+      pluralLower: names.pluralLower,
+      tableName: names.pluralSnake
+    })
+
+    console.log(`\n${green('Created:')} ${targetPath}`)
+    console.log(`${dim('Model:')} ${names.pascal}`)
+    console.log(`${dim('Table:')} ${names.pluralSnake}\n`)
+  } catch (err) {
+    console.error(`\n${red('Error:')} ${err.message}\n`)
+    process.exit(1)
+  }
+}

package/src/commands/make-route.js

@@ -0,0 +1,36 @@
+/**
+ * make:route command
+ * Generates a route file in src/routes/api/
+ */
+
+import { generate, transformName } from '../scaffolding/index.js'
+import { green, red, cyan, dim } from '../cli/colors.js'
+
+export async function run(args, flags) {
+  const name = args[0]
+
+  if (!name) {
+    console.error(`\n${red('Error:')} Route name is required`)
+    console.error(`\nUsage: ${cyan('basicben make:route <name>')}\n`)
+    process.exit(1)
+  }
+
+  const names = transformName(name)
+  const fileName = `${names.lower}.js`
+  const targetPath = `src/routes/api/${fileName}`
+
+  try {
+    const fullPath = generate('route', targetPath, {
+      Name: names.pascal,
+      name: names.camel,
+      lower: names.lower,
+      pluralLower: names.pluralLower
+    })
+
+    console.log(`\n${green('Created:')} ${targetPath}`)
+    console.log(`${dim('Routes:')} /${names.pluralLower}\n`)
+  } catch (err) {
+    console.error(`\n${red('Error:')} ${err.message}\n`)
+    process.exit(1)
+  }
+}

package/src/commands/make-seed.js

@@ -0,0 +1,38 @@
+/**
+ * make:seed command
+ * Generates a seed file in seeds/
+ */
+
+import { generate, transformName } from '../scaffolding/index.js'
+import { green, red, cyan, dim } from '../cli/colors.js'
+
+export async function run(args, flags) {
+  const name = args[0]
+
+  if (!name) {
+    console.error(`\n${red('Error:')} Seed name is required`)
+    console.error(`\nUsage: ${cyan('basicben make:seed <name>')}\n`)
+    console.error(`Examples:`)
+    console.error(`  ${dim('basicben make:seed users')}`)
+    console.error(`  ${dim('basicben make:seed sample_posts')}\n`)
+    process.exit(1)
+  }
+
+  const names = transformName(name)
+  const fileName = `${names.snake}.js`
+  const targetPath = `seeds/${fileName}`
+
+  try {
+    generate('seed', targetPath, {
+      name: names.pascal,
+      tableName: names.pluralSnake,
+      lower: names.lower
+    })
+
+    console.log(`\n${green('Created:')} ${targetPath}`)
+    console.log(`${dim('Run with:')} basicben seed ${names.snake}\n`)
+  } catch (err) {
+    console.error(`\n${red('Error:')} ${err.message}\n`)
+    process.exit(1)
+  }
+}