@strav/cli 0.4.30 → 1.0.0-alpha.4

package/src/commands/db_seed.ts

@@ -1,77 +0,0 @@
-import { join } from 'node:path'
-import { existsSync } from 'node:fs'
-import type { Command } from 'commander'
-import chalk from 'chalk'
-import { bootstrap, shutdown } from '../cli/bootstrap.ts'
-import { freshDatabase, requireLocalEnv } from './migration_fresh.ts'
-import { toSnakeCase } from '@strav/kernel/helpers/strings'
-import BaseModel from '@strav/database/orm/base_model'
-import { Seeder } from '@strav/database/database/seeder'
-
-const SEEDERS_PATH = 'database/seeders'
-
-export function register(program: Command): void {
-  program
-    .command('seed')
-    .alias('db:seed')
-    .description('Seed the database with records')
-    .option('-c, --class <name>', 'Run a specific seeder class')
-    .option('--fresh', 'Drop all tables and re-migrate before seeding')
-    .action(async ({ class: className, fresh }: { class?: string; fresh?: boolean }) => {
-      let db
-      try {
-        const { db: database, registry, introspector } = await bootstrap()
-        db = database
-
-        // Wire BaseModel so factories / seeders can use the ORM
-        new BaseModel(db)
-
-        // --fresh: reset the database first
-        if (fresh) {
-          requireLocalEnv('seed --fresh')
-
-          const applied = await freshDatabase(db, registry, introspector)
-          console.log(chalk.green(`\nFresh migration complete. Applied ${applied} migration(s).`))
-        }
-
-        // Resolve the seeder file
-        const fileName = className
-          ? toSnakeCase(className.replace(/Seeder$/i, '') || 'database') + '_seeder'
-          : 'database_seeder'
-
-        const seederPath = join(process.cwd(), SEEDERS_PATH, `${fileName}.ts`)
-
-        if (!existsSync(seederPath)) {
-          console.error(chalk.red(`Seeder not found: `) + chalk.dim(seederPath))
-          console.error(
-            chalk.dim(
-              `  Run ${chalk.cyan(`strav generate:seeder ${className ?? 'DatabaseSeeder'}`)} to create it.`
-            )
-          )
-          process.exit(1)
-        }
-
-        console.log(chalk.cyan(`\nSeeding database...`))
-
-        const mod = await import(seederPath)
-        const SeederClass = mod.default
-
-        if (!SeederClass || !(SeederClass.prototype instanceof Seeder)) {
-          console.error(
-            chalk.red(`Error: `) + `Default export of ${fileName}.ts must extend Seeder.`
-          )
-          process.exit(1)
-        }
-
-        const seeder = new SeederClass(db) as Seeder
-        await seeder.run()
-
-        console.log(chalk.green('Database seeding complete.'))
-      } 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/db_setup_roles.ts

@@ -1,101 +0,0 @@
-import type { Command } from 'commander'
-import chalk from 'chalk'
-import Configuration from '@strav/kernel/config/configuration'
-import { SQL } from 'bun'
-import { env } from '@strav/kernel/helpers/env'
-
-/**
- * Emit (or apply) the SQL needed to set up the two PostgreSQL roles
- * required by the multi-tenant RLS workflow:
- *
- *   - app role:    NOBYPASSRLS — used by the application; RLS policies apply.
- *   - bypass role: BYPASSRLS   — used by migrations, TenantManager, withoutTenant().
- *
- * Reads the desired role names/passwords from the loaded Configuration
- * (`database.username`, `database.password`, `database.tenant.bypass.username`,
- * `database.tenant.bypass.password`).
- *
- * Must be run by a PostgreSQL superuser (only the superuser can grant the
- * BYPASSRLS attribute). Pass --apply to execute against the configured
- * database; otherwise the SQL is printed for manual review.
- */
-export function register(program: Command): void {
-  program
-    .command('db:setup-roles')
-    .description('Print or apply the SQL to create the app + bypass PostgreSQL roles')
-    .option('--apply', 'Execute the SQL against the database (requires superuser credentials)')
-    .option('--superuser <name>', 'Superuser to connect as when --apply is set', 'postgres')
-    .option('--superuser-password <password>', 'Superuser password (or read from $DB_SUPERUSER_PASSWORD)')
-    .action(async (opts: { apply?: boolean; superuser: string; superuserPassword?: string }) => {
-      try {
-        const config = new Configuration('./config')
-        await config.load()
-
-        const dbName = config.get('database.database') ?? env('DB_DATABASE', 'strav')
-        const appUser = config.get('database.username') ?? env('DB_USER', 'strav_app')
-        const appPassword = config.get('database.password') ?? env('DB_PASSWORD', 'changeme')
-        const bypassUser =
-          config.get('database.tenant.bypass.username') ?? env('DB_BYPASS_USER', 'strav_admin')
-        const bypassPassword =
-          config.get('database.tenant.bypass.password') ?? env('DB_BYPASS_PASSWORD', 'changeme')
-
-        const stmts = [
-          `CREATE ROLE "${appUser}" LOGIN PASSWORD '${appPassword}' NOBYPASSRLS;`,
-          `CREATE ROLE "${bypassUser}" LOGIN PASSWORD '${bypassPassword}' BYPASSRLS;`,
-          `GRANT ALL ON DATABASE "${dbName}" TO "${appUser}", "${bypassUser}";`,
-          `GRANT ALL ON SCHEMA public TO "${appUser}", "${bypassUser}";`,
-          // Default privileges for objects the *current connection* will create.
-          `ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON TABLES TO "${appUser}", "${bypassUser}";`,
-          `ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON SEQUENCES TO "${appUser}", "${bypassUser}";`,
-          // ALTER DEFAULT PRIVILEGES is per-role-of-the-creator. Migrations
-          // run as the bypass role, so without these the app role never
-          // sees grants on tables/sequences the bypass role creates and
-          // any non-bypass query (seeders, request-time inserts) fails
-          // with `permission denied for table …`. Setting them here means
-          // the demo flow `db:setup-roles → fresh → seed` works without
-          // any extra GRANT plumbing.
-          `ALTER DEFAULT PRIVILEGES FOR ROLE "${bypassUser}" IN SCHEMA public GRANT ALL ON TABLES TO "${appUser}";`,
-          `ALTER DEFAULT PRIVILEGES FOR ROLE "${bypassUser}" IN SCHEMA public GRANT ALL ON SEQUENCES TO "${appUser}";`,
-        ]
-
-        if (!opts.apply) {
-          console.log(chalk.cyan('\n-- Run as a PostgreSQL superuser:\n'))
-          for (const s of stmts) console.log(s)
-          console.log(
-            chalk.dim('\n(Use --apply to execute these against the configured database.)')
-          )
-          return
-        }
-
-        const password = opts.superuserPassword ?? env('DB_SUPERUSER_PASSWORD', '')
-        const sql = new SQL({
-          hostname: config.get('database.host') ?? env('DB_HOST', '127.0.0.1'),
-          port: config.get('database.port') ?? env.int('DB_PORT', 5432),
-          username: opts.superuser,
-          password,
-          database: dbName,
-          max: 1,
-        })
-
-        console.log(chalk.cyan(`Applying role setup as superuser "${opts.superuser}"...`))
-        for (const stmt of stmts) {
-          try {
-            await sql.unsafe(stmt)
-            console.log(chalk.dim(`  ok: ${stmt}`))
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err)
-            if (/already exists/i.test(msg)) {
-              console.log(chalk.dim(`  skip (exists): ${stmt}`))
-            } else {
-              throw err
-            }
-          }
-        }
-        await sql.close()
-        console.log(chalk.green('\nRoles set up.'))
-      } catch (err) {
-        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
-        process.exit(1)
-      }
-    })
-}

package/src/commands/generate_api.ts

@@ -1,93 +0,0 @@
-import { join } from 'node:path'
-import type { Command } from 'commander'
-import chalk from 'chalk'
-import SchemaRegistry from '@strav/database/schema/registry'
-import ApiGenerator from '../generators/api_generator.ts'
-import RouteGenerator from '../generators/route_generator.ts'
-import TestGenerator from '../generators/test_generator.ts'
-import DocGenerator from '../generators/doc_generator.ts'
-import type { ApiRoutingConfig } from '../generators/route_generator.ts'
-import type { GeneratorConfig } from '../generators/config.ts'
-import { loadGeneratorConfig, getDatabasePaths, loadTenantIdType } from '../config/loader.ts'
-
-export function register(program: Command): void {
-  program
-    .command('generate:api')
-    .alias('g:api')
-    .description(
-      'Generate services, controllers, policies, validators, events, and routes from schemas'
-    )
-    .option('-f, --force', 'Overwrite existing generated files')
-    .action(async ({ force }: { force?: boolean }) => {
-      try {
-        console.log(chalk.cyan('Generating API layer from schemas...'))
-
-        // Get configured database paths
-        const dbPaths = await getDatabasePaths()
-
-        const registry = new SchemaRegistry()
-        await registry.discover(dbPaths.schemas)
-        registry.validate()
-
-        const schemas = registry.resolve()
-        const tenantIdType = await loadTenantIdType()
-        const representation = registry.buildRepresentation(tenantIdType)
-
-        // Load generator config (if available)
-        const config = await loadGeneratorConfig()
-
-        const apiGen = new ApiGenerator(schemas, representation, config)
-        const apiResult = await apiGen.writeAll(force)
-
-        // Load API routing config from config/http.ts (if available)
-        let apiConfig: Partial<ApiRoutingConfig> | undefined
-        try {
-          const httpConfig = (await import(join(process.cwd(), 'config/http.ts'))).default
-          apiConfig = httpConfig.api
-        } catch {
-          // No config/http.ts or no api section — use defaults
-        }
-
-        const routeGen = new RouteGenerator(schemas, config, apiConfig)
-        const routeResult = await routeGen.writeAll(force)
-
-        const testGen = new TestGenerator(schemas, representation, config, apiConfig)
-        const testResult = await testGen.writeAll(force)
-
-        const docGen = new DocGenerator(schemas, representation, config, apiConfig)
-        const docResult = await docGen.writeAll(force)
-
-        const written = [
-          ...apiResult.written,
-          ...routeResult.written,
-          ...testResult.written,
-          ...docResult.written,
-        ]
-        const skipped = [
-          ...apiResult.skipped,
-          ...routeResult.skipped,
-          ...testResult.skipped,
-          ...docResult.skipped,
-        ]
-
-        if (written.length === 0 && skipped.length === 0) {
-          console.log(chalk.yellow('No API files to generate.'))
-          return
-        }
-
-        for (const file of written) {
-          console.log(chalk.green(`  CREATE  `) + chalk.dim(file.path))
-        }
-        for (const file of skipped) {
-          console.log(chalk.yellow(`  SKIP    `) + chalk.dim(file.path) + chalk.dim(' (already exists)'))
-        }
-
-        if (skipped.length > 0) {
-          console.log(chalk.dim(`\nSkipped ${skipped.length} existing file(s). Use --force to overwrite.`))
-        }
-      } catch (err) {
-        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
-        process.exit(1)
-      }
-    })
-}

package/src/commands/generate_key.ts

@@ -1,47 +0,0 @@
-import { join } from 'node:path'
-import type { Command } from 'commander'
-import chalk from 'chalk'
-
-export function register(program: Command): void {
-  program
-    .command('generate:key')
-    .alias('g:key')
-    .description('Generate an APP_KEY and write it to the .env file')
-    .option('-f, --force', 'Overwrite existing APP_KEY if present')
-    .action(async ({ force }: { force?: boolean }) => {
-      try {
-        const key = crypto.randomUUID()
-        const envPath = join(process.cwd(), '.env')
-        const file = Bun.file(envPath)
-
-        if (await file.exists()) {
-          const contents = await file.text()
-          const hasKey = /^APP_KEY\s*=/m.test(contents)
-
-          if (hasKey && !force) {
-            const current = contents.match(/^APP_KEY\s*=\s*(.*)$/m)?.[1] ?? ''
-            if (current) {
-              console.log(chalk.yellow('APP_KEY already exists in .env. Use --force to overwrite.'))
-              return
-            }
-          }
-
-          if (hasKey) {
-            const updated = contents.replace(/^APP_KEY\s*=.*$/m, `APP_KEY=${key}`)
-            await Bun.write(envPath, updated)
-          } else {
-            const separator = contents.endsWith('\n') ? '' : '\n'
-            await Bun.write(envPath, contents + separator + `APP_KEY=${key}\n`)
-          }
-        } else {
-          await Bun.write(envPath, `APP_KEY=${key}\n`)
-        }
-
-        console.log(chalk.green('APP_KEY generated successfully.'))
-        console.log(chalk.dim(`  ${key}`))
-      } catch (err) {
-        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
-        process.exit(1)
-      }
-    })
-}

package/src/commands/generate_models.ts

@@ -1,49 +0,0 @@
-import type { Command } from 'commander'
-import chalk from 'chalk'
-import SchemaRegistry from '@strav/database/schema/registry'
-import ModelGenerator from '../generators/model_generator.ts'
-import { loadGeneratorConfig, getDatabasePaths, loadTenantIdType } from '../config/loader.ts'
-
-export function register(program: Command): void {
-  program
-    .command('generate:models')
-    .alias('g:models')
-    .description('Generate model classes and enums from schema definitions')
-    .option('-f, --force', 'Overwrite existing generated files')
-    .action(async ({ force }: { force?: boolean }) => {
-      try {
-        const dbPaths = await getDatabasePaths()
-        const config = await loadGeneratorConfig()
-
-        console.log(chalk.cyan('Generating models from schemas...'))
-
-        const registry = new SchemaRegistry()
-        await registry.discover(dbPaths.schemas)
-        registry.validate()
-
-        const tenantIdType = await loadTenantIdType()
-        const representation = registry.buildRepresentation(tenantIdType)
-        const generator = new ModelGenerator(registry.all(), representation, config)
-        const { written, skipped } = await generator.writeAll(force)
-
-        if (written.length === 0 && skipped.length === 0) {
-          console.log(chalk.yellow('No models to generate.'))
-          return
-        }
-
-        for (const file of written) {
-          console.log(chalk.green(`  CREATE  `) + chalk.dim(file.path))
-        }
-        for (const file of skipped) {
-          console.log(chalk.yellow(`  SKIP    `) + chalk.dim(file.path) + chalk.dim(' (already exists)'))
-        }
-
-        if (skipped.length > 0) {
-          console.log(chalk.dim(`\nSkipped ${skipped.length} existing file(s). Use --force to overwrite.`))
-        }
-      } catch (err) {
-        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
-        process.exit(1)
-      }
-    })
-}

package/src/commands/generate_seeder.ts

@@ -1,68 +0,0 @@
-import { join } from 'node:path'
-import { existsSync } from 'node:fs'
-import type { Command } from 'commander'
-import chalk from 'chalk'
-import { toSnakeCase } from '@strav/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 '@strav/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 '@strav/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

@@ -1,167 +0,0 @@
-import type { Command } from 'commander'
-import chalk from 'chalk'
-import { bootstrap, shutdown } from '../cli/bootstrap.ts'
-import SchemaDiffer from '@strav/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(database.tenantIdType)
-        const actual = await introspector.introspect()
-        const diff = new SchemaDiffer().diff(desired, actual)
-
-        const hasChanges =
-          diff.extensions.length > 0 ||
-          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
-        }
-
-        // --- Extension changes ---
-        if (diff.extensions.length > 0) {
-          console.log(chalk.bold('Extension changes:'))
-          for (const x of diff.extensions) {
-            if (x.kind === 'create') {
-              console.log(chalk.green(`  + CREATE EXTENSION  ${x.name}`))
-            } else if (x.kind === 'drop') {
-              console.log(chalk.red(`  - DROP   EXTENSION  ${x.name}`))
-            }
-          }
-          console.log()
-        }
-
-        // --- 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), ${diff.extensions.length} extension 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)
-      }
-    })
-}