@strav/cli 0.4.30 → 1.0.0-alpha.4

package/src/commands/migration_fresh.ts

@@ -1,148 +0,0 @@
-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 '@strav/database/database/database'
-import type SchemaRegistry from '@strav/database/schema/registry'
-import type DatabaseIntrospector from '@strav/database/database/introspector'
-import SchemaDiffer from '@strav/database/database/migration/differ'
-import SqlGenerator from '@strav/database/database/migration/sql_generator'
-import MigrationFileGenerator from '@strav/database/database/migration/file_generator'
-import MigrationTracker from '@strav/database/database/migration/tracker'
-import MigrationRunner from '@strav/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> {
-  console.log(chalk.cyan('\nDropping all tables and types...'))
-
-  const conn = db.isMultiTenant ? db.bypass : db.sql
-
-  const tables = await conn.unsafe(`
-    SELECT table_name FROM information_schema.tables
-    WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
-  `)
-  for (const row of tables as Array<{ table_name: string }>) {
-    await conn.unsafe(`DROP TABLE IF EXISTS "${row.table_name}" CASCADE`)
-  }
-
-  const types = await conn.unsafe(`
-    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 as Array<{ typname: string }>) {
-    await conn.unsafe(`DROP TYPE IF EXISTS "${row.typname}" CASCADE`)
-  }
-
-  console.log(chalk.cyan('Clearing migration directory...'))
-  rmSync(migrationsPath, { recursive: true, force: true })
-
-  console.log(chalk.cyan('Generating fresh migration...'))
-
-  const desired = registry.buildRepresentation(db.tenantIdType)
-  const actual = await introspector.introspect()
-  const diff = new SchemaDiffer().diff(desired, actual)
-
-  const sql = new SqlGenerator(
-    db.tenantIdType,
-    db.tenantTableName,
-    db.tenantFkColumn
-  ).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)
-
-  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 {
-        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

@@ -1,84 +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'
-import SqlGenerator from '@strav/database/database/migration/sql_generator'
-import MigrationFileGenerator from '@strav/database/database/migration/file_generator'
-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')
-    .action(async (opts: { message: string }) => {
-      let db
-      try {
-        const dbPaths = await getDatabasePaths()
-        const { db: database, registry, introspector } = await bootstrap()
-        db = database
-
-        console.log(chalk.cyan('Comparing schema with database...'))
-
-        // Tenant table name + idType are read from the registered tenant
-        // schema (the one with `tenantRegistry: true`). Defaults to
-        // `tenant` / `bigint` if no schema is registered.
-        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(
-          database.tenantIdType,
-          database.tenantTableName,
-          database.tenantFkColumn
-        ).generate(diff)
-        const version = Date.now().toString()
-        const tableOrder = desired.tables.map(t => t.name)
-
-        const fileGen = new MigrationFileGenerator(dbPaths.migrations)
-        const dir = await fileGen.generate(version, opts.message, sql, diff, tableOrder)
-
-        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

@@ -1,54 +0,0 @@
-import type { Command } from 'commander'
-import chalk from 'chalk'
-import { bootstrap, shutdown } from '../cli/bootstrap.ts'
-import MigrationTracker from '@strav/database/database/migration/tracker'
-import MigrationRunner from '@strav/database/database/migration/runner'
-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')
-    .action(async (opts: { batch?: string }) => {
-      let db
-      try {
-        const dbPaths = await getDatabasePaths()
-        const { db: database } = await bootstrap()
-        db = database
-
-        const tracker = new MigrationTracker(db)
-        const runner = new MigrationRunner(db, tracker, dbPaths.migrations)
-
-        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

@@ -1,45 +0,0 @@
-import type { Command } from 'commander'
-import chalk from 'chalk'
-import { bootstrap, shutdown } from '../cli/bootstrap.ts'
-import MigrationTracker from '@strav/database/database/migration/tracker'
-import MigrationRunner from '@strav/database/database/migration/runner'
-import { getDatabasePaths } from '../config/loader.ts'
-
-export function register(program: Command): void {
-  program
-    .command('migrate')
-    .alias('migration:run')
-    .description('Run pending migrations')
-    .action(async () => {
-      let db
-      try {
-        const dbPaths = await getDatabasePaths()
-        const { db: database } = await bootstrap()
-        db = database
-
-        const tracker = new MigrationTracker(db)
-        const runner = new MigrationRunner(db, tracker, dbPaths.migrations)
-
-        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)
-      }
-    })
-}

package/src/commands/package_install.ts

@@ -1,161 +0,0 @@
-import { readdirSync, mkdirSync, existsSync } from 'node:fs'
-import { join, dirname, resolve } from 'node:path'
-import type { Command } from 'commander'
-import chalk from 'chalk'
-
-export function register(program: Command): void {
-  program
-    .command('install <name>')
-    .aliases(['package:install', 'i'])
-    .description('Copy config and schema stubs from a @strav/* package into your project')
-    .option('-f, --force', 'Overwrite existing files')
-    .action(async (name: string, { force }: { force?: boolean }) => {
-      try {
-        const packageName = name.startsWith('@strav/') ? name : `@strav/${name}`
-
-        const packageRoot = await resolvePackageRoot(packageName)
-        if (!packageRoot) {
-          console.error(chalk.red(`Package "${packageName}" is not installed.`))
-          process.exit(1)
-        }
-
-        const stubsDir = join(packageRoot, 'stubs')
-        if (!dirExists(stubsDir)) {
-          console.log(chalk.yellow(`Package "${packageName}" has no stubs to install.`))
-          return
-        }
-
-        let copied = 0
-        let skipped = 0
-
-        // Copy config stubs → ./config/
-        const configStubsDir = join(stubsDir, 'config')
-        if (dirExists(configStubsDir)) {
-          const result = await copyStubs(configStubsDir, join(process.cwd(), 'config'), force)
-          copied += result.copied
-          skipped += result.skipped
-        }
-
-        // Copy schema stubs → ./database/schemas/
-        const schemaStubsDir = join(stubsDir, 'schemas')
-        if (dirExists(schemaStubsDir)) {
-          const result = await copyStubs(
-            schemaStubsDir,
-            join(process.cwd(), 'database', 'schemas'),
-            force
-          )
-          copied += result.copied
-          skipped += result.skipped
-        }
-
-        // Copy action stubs → ./actions/
-        const actionStubsDir = join(stubsDir, 'actions')
-        if (dirExists(actionStubsDir)) {
-          const result = await copyStubs(actionStubsDir, join(process.cwd(), 'actions'), force)
-          copied += result.copied
-          skipped += result.skipped
-        }
-
-        // Copy email template stubs → ./resources/views/emails/
-        const emailStubsDir = join(stubsDir, 'emails')
-        if (dirExists(emailStubsDir)) {
-          const result = await copyStubs(
-            emailStubsDir,
-            join(process.cwd(), 'resources', 'views', 'emails'),
-            force,
-            ['.strav']
-          )
-          copied += result.copied
-          skipped += result.skipped
-        }
-
-        if (copied === 0 && skipped === 0) {
-          console.log(chalk.yellow(`No stubs found in "${packageName}".`))
-        } else {
-          if (copied > 0) {
-            console.log(
-              chalk.green(`\nInstalled ${copied} file${copied > 1 ? 's' : ''} from ${packageName}.`)
-            )
-          }
-          if (skipped > 0) {
-            console.log(
-              chalk.dim(
-                `Skipped ${skipped} existing file${skipped > 1 ? 's' : ''}. Use --force to overwrite.`
-              )
-            )
-          }
-        }
-      } catch (err) {
-        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
-        process.exit(1)
-      }
-    })
-}
-
-async function resolvePackageRoot(packageName: string): Promise<string | null> {
-  // 1. Try node_modules (regular npm install)
-  const nodeModulesPath = join(process.cwd(), 'node_modules', ...packageName.split('/'))
-  if (existsSync(join(nodeModulesPath, 'package.json'))) {
-    return nodeModulesPath
-  }
-
-  // 2. Try workspace resolution (Bun workspaces / monorepo)
-  try {
-    const rootPkg = await Bun.file(resolve('package.json')).json()
-    const workspaces: string[] = rootPkg.workspaces ?? []
-    for (const ws of workspaces) {
-      const wsPath = resolve(ws)
-      const pkgPath = join(wsPath, 'package.json')
-      if (!existsSync(pkgPath)) continue
-      const wsPkg = await Bun.file(pkgPath).json()
-      if (wsPkg.name === packageName) return wsPath
-    }
-  } catch {
-    // No package.json or no workspaces
-  }
-
-  return null
-}
-
-function dirExists(path: string): boolean {
-  try {
-    readdirSync(path)
-    return true
-  } catch {
-    return false
-  }
-}
-
-async function copyStubs(
-  srcDir: string,
-  destDir: string,
-  force?: boolean,
-  extensions: string[] = ['.ts']
-): Promise<{ copied: number; skipped: number }> {
-  let copied = 0
-  let skipped = 0
-
-  const files = readdirSync(srcDir).filter(f => extensions.some(ext => f.endsWith(ext)))
-
-  for (const file of files) {
-    const srcPath = join(srcDir, file)
-    const destPath = join(destDir, file)
-    const destFile = Bun.file(destPath)
-
-    if ((await destFile.exists()) && !force) {
-      const relative = destPath.replace(process.cwd() + '/', '')
-      console.log(chalk.yellow(`  SKIP  ${relative} (already exists)`))
-      skipped++
-      continue
-    }
-
-    mkdirSync(destDir, { recursive: true })
-    const content = await Bun.file(srcPath).text()
-    await Bun.write(destPath, content)
-    const relative = destPath.replace(process.cwd() + '/', '')
-    console.log(chalk.green(`  CREATE  ${relative}`))
-    copied++
-  }
-
-  return { copied, skipped }
-}

package/src/commands/queue_flush.ts

@@ -1,35 +0,0 @@
-import type { Command } from 'commander'
-import chalk from 'chalk'
-import { bootstrap, shutdown } from '../cli/bootstrap.ts'
-import Queue from '@strav/queue/queue/queue'
-
-export function register(program: Command): void {
-  program
-    .command('queue:flush')
-    .description('Delete all jobs from a queue')
-    .option('--queue <name>', 'Queue to flush', 'default')
-    .option('--failed', 'Also flush failed jobs')
-    .action(async options => {
-      let db
-      try {
-        const { db: database, config } = await bootstrap()
-        db = database
-
-        new Queue(db, config)
-        await Queue.ensureTables()
-
-        const cleared = await Queue.clear(options.queue)
-        console.log(chalk.green(`Cleared ${cleared} pending job(s) from "${options.queue}".`))
-
-        if (options.failed) {
-          const failedCleared = await Queue.clearFailed(options.queue)
-          console.log(chalk.green(`Cleared ${failedCleared} failed job(s).`))
-        }
-      } 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/queue_retry.ts

@@ -1,34 +0,0 @@
-import type { Command } from 'commander'
-import chalk from 'chalk'
-import { bootstrap, shutdown } from '../cli/bootstrap.ts'
-import Queue from '@strav/queue/queue/queue'
-
-export function register(program: Command): void {
-  program
-    .command('queue:retry')
-    .description('Retry failed jobs by moving them back to the queue')
-    .option('--queue <name>', 'Only retry jobs from this queue')
-    .action(async options => {
-      let db
-      try {
-        const { db: database, config } = await bootstrap()
-        db = database
-
-        new Queue(db, config)
-        await Queue.ensureTables()
-
-        const count = await Queue.retryFailed(options.queue)
-
-        if (count === 0) {
-          console.log(chalk.green('No failed jobs to retry.'))
-        } else {
-          console.log(chalk.green(`Moved ${count} failed job(s) back to the queue.`))
-        }
-      } 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/queue_work.ts

@@ -1,101 +0,0 @@
-import type { Command } from 'commander'
-import chalk from 'chalk'
-import path from 'node:path'
-import { bootstrap, shutdown, withProviders } from '../cli/bootstrap.ts'
-import type Application from '@strav/kernel/core/application'
-import type ServiceProvider from '@strav/kernel/core/service_provider'
-import type Database from '@strav/database/database/database'
-import Queue from '@strav/queue/queue/queue'
-import QueueProvider from '@strav/queue/providers/queue_provider'
-import Worker from '@strav/queue/queue/worker'
-
-/**
- * Conventional file the worker loads on start. Its top-level `Queue.handle(...)`
- * calls register the job handlers, and its `providers` export lists the service
- * providers the worker boots — mirroring `start/providers.ts` for the web entry.
- */
-const JOBS_FILE = 'start/jobs.ts'
-
-export function register(program: Command): void {
-  program
-    .command('queue:work')
-    .description('Start processing queued jobs')
-    .option('--queue <name>', 'Queue to process', 'default')
-    .option('--sleep <ms>', 'Poll interval in milliseconds', '1000')
-    .action(async options => {
-      const queue = options.queue
-      const sleep = parseInt(options.sleep)
-
-      let app: Application | undefined
-      let db: Database | undefined
-
-      try {
-        const jobsPath = path.resolve(JOBS_FILE)
-
-        if (await Bun.file(jobsPath).exists()) {
-          // Importing start/jobs.ts runs its top-level Queue.handle(...) calls
-          // and exposes the provider list the worker needs. Booting those
-          // providers wires the facades (mail, notification, …) that handlers
-          // depend on — bootstrap() alone leaves them unregistered.
-          const jobs = await import(jobsPath)
-          const providers: ServiceProvider[] = Array.isArray(jobs.providers)
-            ? [...jobs.providers]
-            : []
-
-          if (providers.length === 0) {
-            throw new Error(
-              `${JOBS_FILE} must export a \`providers\` array — the service ` +
-                `providers the worker boots (ConfigProvider, DatabaseProvider, ` +
-                `QueueProvider, plus any facade providers your handlers use).`,
-            )
-          }
-
-          // QueueProvider wires the Queue singleton and ensures the tables —
-          // add it if the app's provider list left it out.
-          if (!providers.some(p => p.name === 'queue')) {
-            providers.push(new QueueProvider())
-          }
-
-          // signalHandlers: false — the Worker installs its own SIGINT/SIGTERM
-          // handlers that drain the in-flight job before start() returns. We
-          // call app.shutdown() only afterwards (in finally), so providers are
-          // never torn down while a job is still running.
-          app = await withProviders(providers, { signalHandlers: false })
-        } else {
-          console.warn(
-            chalk.yellow(`No ${JOBS_FILE} found — the worker has no registered handlers.`),
-          )
-          console.warn(
-            chalk.dim(
-              `  Create ${JOBS_FILE} with your Queue.handle(...) calls and a ` +
-                `\`providers\` export, or every dispatched job will fail.`,
-            ),
-          )
-          const { db: database, config } = await bootstrap()
-          db = database
-          new Queue(db, config)
-          await Queue.ensureTables()
-        }
-
-        const handlers = [...Queue.handlers.keys()]
-
-        console.log(chalk.cyan(`Worker starting on queue "${queue}"...`))
-        console.log(chalk.dim(`  poll interval: ${sleep}ms`))
-        console.log(
-          chalk.dim(`  handlers: ${handlers.length > 0 ? handlers.join(', ') : 'none'}`),
-        )
-        console.log(chalk.dim('  Press Ctrl+C to stop.\n'))
-
-        const worker = new Worker({ queue, sleep })
-        await worker.start()
-
-        console.log(chalk.dim('\nWorker stopped.'))
-      } catch (err) {
-        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
-        process.exit(1)
-      } finally {
-        if (app) await app.shutdown()
-        if (db) await shutdown(db)
-      }
-    })
-}