@strav/cli 0.1.0

package/src/commands/generate_seeder.ts

@@ -0,0 +1,68 @@
+import { join } from 'node:path'
+import { existsSync } from 'node:fs'
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { toSnakeCase } from '@stravigor/kernel/helpers/strings'
+import { formatAndWrite } from '../generators/config.ts'
+
+const SEEDERS_PATH = 'database/seeders'
+
+export function register(program: Command): void {
+  program
+    .command('generate:seeder <name>')
+    .alias('g:seeder')
+    .description('Generate a database seeder class')
+    .option('-f, --force', 'Overwrite existing file')
+    .action(async (name: string, { force }: { force?: boolean }) => {
+      try {
+        // Normalize: "UserSeeder" | "User" → class UserSeeder, file user_seeder.ts
+        const className = name.endsWith('Seeder') ? name : `${name}Seeder`
+        const baseName = className.replace(/Seeder$/, '') || 'Database'
+        const fileName = toSnakeCase(baseName) + '_seeder'
+        const filePath = join(SEEDERS_PATH, `${fileName}.ts`)
+
+        if (existsSync(filePath) && !force) {
+          console.log(chalk.yellow(`File already exists: `) + chalk.dim(filePath))
+          console.log(chalk.dim('  Use --force to overwrite.'))
+          return
+        }
+
+        const isDatabaseSeeder = baseName === 'Database'
+
+        const content = isDatabaseSeeder
+          ? generateDatabaseSeeder(className)
+          : generateSeeder(className)
+
+        await formatAndWrite([{ path: filePath, content }])
+
+        console.log(chalk.green(`Created: `) + chalk.dim(filePath))
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
+        process.exit(1)
+      }
+    })
+}
+
+function generateDatabaseSeeder(className: string): string {
+  return `import { Seeder } from '@stravigor/database/database'
+
+export default class ${className} extends Seeder {
+  async run(): Promise<void> {
+    // Call sub-seeders:
+    // await this.call(UserSeeder)
+  }
+}
+`
+}
+
+function generateSeeder(className: string): string {
+  return `import { Seeder } from '@stravigor/database/database'
+
+export default class ${className} extends Seeder {
+  async run(): Promise<void> {
+    // Use factories or direct inserts to seed data:
+    // await UserFactory.createMany(10)
+  }
+}
+`
+}

package/src/commands/migration_compare.ts

@@ -0,0 +1,153 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { bootstrap, shutdown } from '../cli/bootstrap.ts'
+import SchemaDiffer from '@stravigor/database/database/migration/differ'
+
+export function register(program: Command): void {
+  program
+    .command('compare')
+    .alias('migration:compare')
+    .description('Compare schema with database and report differences')
+    .action(async () => {
+      let db
+      try {
+        const { db: database, registry, introspector } = await bootstrap()
+        db = database
+
+        console.log(chalk.cyan('Comparing schema with database...\n'))
+
+        const desired = registry.buildRepresentation()
+        const actual = await introspector.introspect()
+        const diff = new SchemaDiffer().diff(desired, actual)
+
+        const hasChanges =
+          diff.enums.length > 0 ||
+          diff.tables.length > 0 ||
+          diff.constraints.length > 0 ||
+          diff.indexes.length > 0
+
+        if (!hasChanges) {
+          console.log(chalk.green('Schema is in sync with the database.'))
+          return
+        }
+
+        // --- Enum changes ---
+        if (diff.enums.length > 0) {
+          console.log(chalk.bold('Enum changes:'))
+          for (const e of diff.enums) {
+            if (e.kind === 'create') {
+              console.log(chalk.green(`  + CREATE  ${e.name} (${e.values.join(', ')})`))
+            } else if (e.kind === 'drop') {
+              console.log(chalk.red(`  - DROP    ${e.name}`))
+            } else if (e.kind === 'modify') {
+              console.log(chalk.yellow(`  ~ MODIFY  ${e.name} (add: ${e.addedValues.join(', ')})`))
+            }
+          }
+          console.log()
+        }
+
+        // --- Table changes ---
+        if (diff.tables.length > 0) {
+          console.log(chalk.bold('Table changes:'))
+          for (const t of diff.tables) {
+            if (t.kind === 'create') {
+              console.log(
+                chalk.green(`  + CREATE  ${t.table.name}`) +
+                  chalk.dim(` (${t.table.columns.length} columns)`)
+              )
+            } else if (t.kind === 'drop') {
+              console.log(chalk.red(`  - DROP    ${t.table.name}`))
+            } else if (t.kind === 'modify') {
+              console.log(chalk.yellow(`  ~ MODIFY  ${t.tableName}`))
+              for (const c of t.columns) {
+                if (c.kind === 'add') {
+                  console.log(
+                    chalk.green(
+                      `      + ADD COLUMN    ${c.column.name} (${typeof c.column.pgType === 'string' ? c.column.pgType : 'custom'})`
+                    )
+                  )
+                } else if (c.kind === 'drop') {
+                  console.log(chalk.red(`      - DROP COLUMN   ${c.column.name}`))
+                } else if (c.kind === 'alter') {
+                  const changes: string[] = []
+                  if (c.typeChange) changes.push(`type: ${c.typeChange.from} -> ${c.typeChange.to}`)
+                  if (c.nullableChange)
+                    changes.push(c.nullableChange.to ? 'set NOT NULL' : 'drop NOT NULL')
+                  if (c.defaultChange) changes.push('default changed')
+                  console.log(
+                    chalk.yellow(`      ~ ALTER COLUMN  ${c.columnName} (${changes.join(', ')})`)
+                  )
+                }
+              }
+            }
+          }
+          console.log()
+        }
+
+        // --- Constraint changes ---
+        if (diff.constraints.length > 0) {
+          console.log(chalk.bold('Constraint changes:'))
+          for (const c of diff.constraints) {
+            if (c.kind === 'add_fk') {
+              console.log(
+                chalk.green(
+                  `  + ADD FK  ${c.tableName}(${c.constraint.columns.join(',')}) -> ${c.constraint.referencedTable}`
+                )
+              )
+            } else if (c.kind === 'drop_fk') {
+              console.log(
+                chalk.red(
+                  `  - DROP FK ${c.tableName}(${c.constraint.columns.join(',')}) -> ${c.constraint.referencedTable}`
+                )
+              )
+            } else if (c.kind === 'add_unique') {
+              console.log(
+                chalk.green(`  + ADD UQ  ${c.tableName}(${c.constraint.columns.join(',')})`)
+              )
+            } else if (c.kind === 'drop_unique') {
+              console.log(
+                chalk.red(`  - DROP UQ ${c.tableName}(${c.constraint.columns.join(',')})`)
+              )
+            }
+          }
+          console.log()
+        }
+
+        // --- Index changes ---
+        if (diff.indexes.length > 0) {
+          console.log(chalk.bold('Index changes:'))
+          for (const i of diff.indexes) {
+            if (i.kind === 'add') {
+              const unique = i.index.unique ? 'UNIQUE ' : ''
+              console.log(
+                chalk.green(
+                  `  + CREATE ${unique}INDEX  ${i.tableName}(${i.index.columns.join(',')})`
+                )
+              )
+            } else if (i.kind === 'drop') {
+              console.log(
+                chalk.red(`  - DROP INDEX    ${i.tableName}(${i.index.columns.join(',')})`)
+              )
+            }
+          }
+          console.log()
+        }
+
+        // --- Summary ---
+        const creates = diff.tables.filter(t => t.kind === 'create').length
+        const drops = diff.tables.filter(t => t.kind === 'drop').length
+        const modifies = diff.tables.filter(t => t.kind === 'modify').length
+        console.log(
+          chalk.bold('Summary: ') +
+            `${creates} table(s) to create, ${drops} to drop, ${modifies} to modify, ` +
+            `${diff.enums.length} enum change(s), ${diff.constraints.length} constraint change(s), ${diff.indexes.length} index change(s)`
+        )
+        console.log(chalk.dim('\nRun "bun strav generate:migration" to create migration files.'))
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
+        process.exit(1)
+      } finally {
+        if (db) await shutdown(db)
+      }
+    })
+}

package/src/commands/migration_fresh.ts

@@ -0,0 +1,149 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { createInterface } from 'node:readline'
+import { rmSync } from 'node:fs'
+import { bootstrap, shutdown } from '../cli/bootstrap.ts'
+import type Database from '@stravigor/database/database/database'
+import type SchemaRegistry from '@stravigor/database/schema/registry'
+import type DatabaseIntrospector from '@stravigor/database/database/introspector'
+import SchemaDiffer from '@stravigor/database/database/migration/differ'
+import SqlGenerator from '@stravigor/database/database/migration/sql_generator'
+import MigrationFileGenerator from '@stravigor/database/database/migration/file_generator'
+import MigrationTracker from '@stravigor/database/database/migration/tracker'
+import MigrationRunner from '@stravigor/database/database/migration/runner'
+import { getDatabasePaths } from '../config/loader.ts'
+
+/**
+ * Drop all tables and enum types, regenerate a single migration from
+ * the current schema definitions, and run it.
+ *
+ * Shared by `fresh` and `seed --fresh`.
+ */
+export async function freshDatabase(
+  db: Database,
+  registry: SchemaRegistry,
+  introspector: DatabaseIntrospector,
+  migrationsPath: string = 'database/migrations'
+): Promise<number> {
+  // Drop all tables in public schema
+  console.log(chalk.cyan('\nDropping all tables and types...'))
+
+  const tables = await db.sql`
+    SELECT table_name FROM information_schema.tables
+    WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
+  `
+  for (const row of tables) {
+    await db.sql.unsafe(`DROP TABLE IF EXISTS "${row.table_name}" CASCADE`)
+  }
+
+  // Drop all enum types in public schema
+  const types = await db.sql`
+    SELECT t.typname
+    FROM pg_type t
+    JOIN pg_namespace n ON n.oid = t.typnamespace
+    WHERE n.nspname = 'public'
+      AND t.typtype = 'e'
+  `
+  for (const row of types) {
+    await db.sql.unsafe(`DROP TYPE IF EXISTS "${row.typname}" CASCADE`)
+  }
+
+  // Delete existing migration files
+  console.log(chalk.cyan('Clearing migration directory...'))
+  rmSync(migrationsPath, { recursive: true, force: true })
+
+  // Generate new migration
+  console.log(chalk.cyan('Generating fresh migration...'))
+
+  const desired = registry.buildRepresentation()
+  const actual = await introspector.introspect()
+  const diff = new SchemaDiffer().diff(desired, actual)
+
+  const sql = new SqlGenerator().generate(diff)
+  const version = Date.now().toString()
+  const tableOrder = desired.tables.map(t => t.name)
+
+  const fileGen = new MigrationFileGenerator(migrationsPath)
+  await fileGen.generate(version, 'fresh', sql, diff, tableOrder)
+
+  // Run the migration
+  console.log(chalk.cyan('Running migration...'))
+
+  const tracker = new MigrationTracker(db)
+  const runner = new MigrationRunner(db, tracker, migrationsPath)
+  const result = await runner.run()
+
+  return result.applied.length
+}
+
+/**
+ * Guard that ensures APP_ENV is "local". Exits the process if not.
+ */
+export function requireLocalEnv(commandName: string): void {
+  const appEnv = process.env.APP_ENV
+  if (appEnv !== 'local') {
+    console.error(
+      chalk.red('REJECTED: ') + `${commandName} can only run when APP_ENV is set to "local".`
+    )
+    if (!appEnv) {
+      console.error(chalk.dim('  APP_ENV is not defined in .env'))
+    } else {
+      console.error(chalk.dim(`  Current APP_ENV: "${appEnv}"`))
+    }
+    process.exit(1)
+  }
+}
+
+export function register(program: Command): void {
+  program
+    .command('fresh')
+    .alias('migration:fresh')
+    .description('Reset database and migrations, regenerate and run from scratch')
+    .action(async () => {
+      requireLocalEnv('fresh')
+
+      // 6-digit challenge
+      const challenge = String(Math.floor(100000 + Math.random() * 900000))
+      console.log(
+        chalk.red('WARNING: ') +
+          'This will ' +
+          chalk.red('destroy ALL data') +
+          ' in the database and recreate everything from schemas.'
+      )
+      console.log(`\n  Type ${chalk.yellow(challenge)} to confirm:\n`)
+
+      const answer = await prompt('  > ')
+      if (answer.trim() !== challenge) {
+        console.error(chalk.red('\nChallenge code does not match. Operation cancelled.'))
+        process.exit(1)
+      }
+
+      let db
+      try {
+        // Get configured database paths
+        const dbPaths = await getDatabasePaths()
+
+        const { db: database, registry, introspector } = await bootstrap()
+        db = database
+
+        const applied = await freshDatabase(db, registry, introspector, dbPaths.migrations)
+
+        console.log(chalk.green(`\nFresh migration complete. Applied ${applied} migration(s).`))
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
+        process.exit(1)
+      } finally {
+        if (db) await shutdown(db)
+      }
+    })
+}
+
+function prompt(question: string): Promise<string> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+  return new Promise(resolve => {
+    rl.question(question, answer => {
+      rl.close()
+      resolve(answer)
+    })
+  })
+}

package/src/commands/migration_generate.ts

@@ -0,0 +1,93 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { bootstrap, shutdown } from '../cli/bootstrap.ts'
+import SchemaDiffer from '@stravigor/database/database/migration/differ'
+import SqlGenerator from '@stravigor/database/database/migration/sql_generator'
+import MigrationFileGenerator from '@stravigor/database/database/migration/file_generator'
+import { discoverDomains } from '@stravigor/database'
+import { getDatabasePaths } from '../config/loader.ts'
+
+export function register(program: Command): void {
+  program
+    .command('generate:migration')
+    .aliases(['migration:generate', 'g:migration'])
+    .description('Generate migration files from schema changes')
+    .option('-m, --message <message>', 'Migration message', 'migration')
+    .option('-s, --scope <scope>', 'Domain (e.g., public, tenant, factory, marketing)', 'public')
+    .action(async (opts: { message: string; scope: string }) => {
+      let db
+      try {
+        // Get configured database paths
+        const dbPaths = await getDatabasePaths()
+
+        // Validate scope against available domains
+        const availableDomains = discoverDomains(dbPaths.schemas)
+        if (!availableDomains.includes(opts.scope)) {
+          throw new Error(`Invalid domain: ${opts.scope}. Available domains: ${availableDomains.join(', ')}`)
+        }
+        const scope = opts.scope
+
+        const { db: database, registry, introspector } = await bootstrap(scope)
+        db = database
+
+        console.log(chalk.cyan(`Comparing ${scope} schema with database...`))
+
+        const desired = registry.buildRepresentation()
+        const actual = await introspector.introspect()
+        const diff = new SchemaDiffer().diff(desired, actual)
+
+        const hasChanges =
+          diff.enums.length > 0 ||
+          diff.tables.length > 0 ||
+          diff.constraints.length > 0 ||
+          diff.indexes.length > 0
+
+        if (!hasChanges) {
+          console.log(chalk.green('No changes detected. Schema is in sync with the database.'))
+          return
+        }
+
+        const sql = new SqlGenerator().generate(diff)
+        const version = Date.now().toString()
+
+        // Use the table order from the desired representation (already dependency-ordered)
+        const tableOrder = desired.tables.map(t => t.name)
+
+        // Use scoped migrations path from configuration
+        const scopedPath = `${dbPaths.migrations}/${scope}`
+        const fileGen = new MigrationFileGenerator(scopedPath)
+        const dir = await fileGen.generate(version, opts.message, sql, diff, tableOrder)
+
+        // Print summary
+        console.log(chalk.green(`\nMigration generated: ${version}`))
+        console.log(chalk.dim(`  Directory: ${dir}`))
+        console.log(chalk.dim(`  Message: ${opts.message}\n`))
+
+        const counts: string[] = []
+        const creates = diff.tables.filter(t => t.kind === 'create').length
+        const drops = diff.tables.filter(t => t.kind === 'drop').length
+        const modifies = diff.tables.filter(t => t.kind === 'modify').length
+        if (creates > 0) counts.push(chalk.green(`${creates} table(s) to create`))
+        if (drops > 0) counts.push(chalk.red(`${drops} table(s) to drop`))
+        if (modifies > 0) counts.push(chalk.yellow(`${modifies} table(s) to modify`))
+
+        const enumCreates = diff.enums.filter(e => e.kind === 'create').length
+        const enumDrops = diff.enums.filter(e => e.kind === 'drop').length
+        const enumModifies = diff.enums.filter(e => e.kind === 'modify').length
+        if (enumCreates > 0) counts.push(chalk.green(`${enumCreates} enum(s) to create`))
+        if (enumDrops > 0) counts.push(chalk.red(`${enumDrops} enum(s) to drop`))
+        if (enumModifies > 0) counts.push(chalk.yellow(`${enumModifies} enum(s) to modify`))
+
+        if (diff.constraints.length > 0)
+          counts.push(`${diff.constraints.length} constraint change(s)`)
+        if (diff.indexes.length > 0) counts.push(`${diff.indexes.length} index change(s)`)
+
+        console.log('  Summary: ' + counts.join(', '))
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
+        process.exit(1)
+      } finally {
+        if (db) await shutdown(db)
+      }
+    })
+}

package/src/commands/migration_rollback.ts

@@ -0,0 +1,66 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { bootstrap, shutdown } from '../cli/bootstrap.ts'
+import MigrationTracker from '@stravigor/database/database/migration/tracker'
+import MigrationRunner from '@stravigor/database/database/migration/runner'
+import { discoverDomains } from '@stravigor/database'
+import { getDatabasePaths } from '../config/loader.ts'
+
+export function register(program: Command): void {
+  program
+    .command('rollback')
+    .alias('migration:rollback')
+    .description('Rollback migrations by batch')
+    .option('--batch <number>', 'Specific batch number to rollback')
+    .option('-s, --scope <scope>', 'Domain (e.g., public, tenant, factory, marketing)', 'public')
+    .action(async (opts: { batch?: string; scope: string }) => {
+      let db
+      try {
+        // Get configured database paths
+        const dbPaths = await getDatabasePaths()
+
+        // Validate scope against available domains
+        const availableDomains = discoverDomains(dbPaths.schemas)
+        if (!availableDomains.includes(opts.scope)) {
+          throw new Error(`Invalid domain: ${opts.scope}. Available domains: ${availableDomains.join(', ')}`)
+        }
+        const scope = opts.scope
+
+        const { db: database } = await bootstrap()
+        db = database
+
+        const scopedPath = `${dbPaths.migrations}/${scope}`
+        const tracker = new MigrationTracker(db, scope)
+        const runner = new MigrationRunner(db, tracker, scopedPath, scope)
+
+        const batchNum = opts.batch ? parseInt(opts.batch, 10) : undefined
+
+        console.log(
+          batchNum
+            ? chalk.cyan(`Rolling back batch ${batchNum}...`)
+            : chalk.cyan('Rolling back last batch...')
+        )
+
+        const result = await runner.rollback(batchNum)
+
+        if (result.rolledBack.length === 0) {
+          console.log(chalk.yellow('Nothing to rollback.'))
+          return
+        }
+
+        console.log(
+          chalk.green(
+            `\nRolled back ${result.rolledBack.length} migration(s) from batch ${result.batch}:`
+          )
+        )
+        for (const version of result.rolledBack) {
+          console.log(chalk.dim(`  - ${version}`))
+        }
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
+        process.exit(1)
+      } finally {
+        if (db) await shutdown(db)
+      }
+    })
+}

package/src/commands/migration_run.ts

@@ -0,0 +1,57 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { bootstrap, shutdown } from '../cli/bootstrap.ts'
+import MigrationTracker from '@stravigor/database/database/migration/tracker'
+import MigrationRunner from '@stravigor/database/database/migration/runner'
+import { discoverDomains } from '@stravigor/database'
+import { getDatabasePaths } from '../config/loader.ts'
+
+export function register(program: Command): void {
+  program
+    .command('migrate')
+    .alias('migration:run')
+    .description('Run pending migrations')
+    .option('-s, --scope <scope>', 'Domain (e.g., public, tenant, factory, marketing)', 'public')
+    .action(async (opts: { scope: string }) => {
+      let db
+      try {
+        // Get configured database paths
+        const dbPaths = await getDatabasePaths()
+
+        // Validate scope against available domains
+        const availableDomains = discoverDomains(dbPaths.schemas)
+        if (!availableDomains.includes(opts.scope)) {
+          throw new Error(`Invalid domain: ${opts.scope}. Available domains: ${availableDomains.join(', ')}`)
+        }
+        const scope = opts.scope
+
+        const { db: database } = await bootstrap()
+        db = database
+
+        const scopedPath = `${dbPaths.migrations}/${scope}`
+        const tracker = new MigrationTracker(db, scope)
+        const runner = new MigrationRunner(db, tracker, scopedPath, scope)
+
+        console.log(chalk.cyan('Running pending migrations...'))
+
+        const result = await runner.run()
+
+        if (result.applied.length === 0) {
+          console.log(chalk.green('Nothing to migrate. All migrations are up to date.'))
+          return
+        }
+
+        console.log(
+          chalk.green(`\nApplied ${result.applied.length} migration(s) in batch ${result.batch}:`)
+        )
+        for (const version of result.applied) {
+          console.log(chalk.dim(`  - ${version}`))
+        }
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
+        process.exit(1)
+      } finally {
+        if (db) await shutdown(db)
+      }
+    })
+}