@stravigor/core 0.1.0

package/src/cli/commands/migration_compare.ts

@@ -0,0 +1,152 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { bootstrap, shutdown } from '../bootstrap.ts'
+import SchemaDiffer from '../../database/migration/differ.ts'
+
+export function registerMigrationCompare(program: Command): void {
+  program
+    .command('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 migration:generate" 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/cli/commands/migration_fresh.ts

@@ -0,0 +1,123 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { createInterface } from 'node:readline'
+import { rmSync } from 'node:fs'
+import { bootstrap, shutdown } from '../bootstrap.ts'
+import SchemaDiffer from '../../database/migration/differ.ts'
+import SqlGenerator from '../../database/migration/sql_generator.ts'
+import MigrationFileGenerator from '../../database/migration/file_generator.ts'
+import MigrationTracker from '../../database/migration/tracker.ts'
+import MigrationRunner from '../../database/migration/runner.ts'
+
+const MIGRATIONS_PATH = 'database/migrations'
+
+export function registerMigrationFresh(program: Command): void {
+  program
+    .command('migration:fresh')
+    .description('Reset database and migrations, regenerate and run from scratch')
+    .action(async () => {
+      // --- Safety check 1: APP_ENV must be "local" ---
+      const appEnv = process.env.APP_ENV
+      if (appEnv !== 'local') {
+        console.error(
+          chalk.red('REJECTED: ') + 'migration:fresh 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)
+      }
+
+      // --- Safety check 2: 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 { db: database, registry, introspector } = await bootstrap()
+        db = database
+
+        // --- Step 1: Drop all tables and enum types ---
+        console.log(chalk.cyan('\nDropping all tables and types...'))
+
+        // Drop all tables in public schema
+        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`)
+        }
+
+        // --- Step 2: Delete existing migration files ---
+        console.log(chalk.cyan('Clearing migration directory...'))
+        rmSync(MIGRATIONS_PATH, { recursive: true, force: true })
+
+        // --- Step 3: Generate new migration ---
+        console.log(chalk.cyan('Generating fresh migration...'))
+
+        const desired = registry.buildRepresentation()
+        const actual = await introspector.introspect() // should be empty now
+        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(MIGRATIONS_PATH)
+        await fileGen.generate(version, 'fresh', sql, diff, tableOrder)
+
+        // --- Step 4: Run the migration ---
+        console.log(chalk.cyan('Running migration...'))
+
+        const tracker = new MigrationTracker(db)
+        const runner = new MigrationRunner(db, tracker, MIGRATIONS_PATH)
+        const result = await runner.run()
+
+        console.log(
+          chalk.green(`\nFresh migration complete. Applied ${result.applied.length} 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/cli/commands/migration_generate.ts

@@ -0,0 +1,79 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { bootstrap, shutdown } from '../bootstrap.ts'
+import SchemaDiffer from '../../database/migration/differ.ts'
+import SqlGenerator from '../../database/migration/sql_generator.ts'
+import MigrationFileGenerator from '../../database/migration/file_generator.ts'
+
+const MIGRATIONS_PATH = 'database/migrations'
+
+export function registerMigrationGenerate(program: Command): void {
+  program
+    .command('migration:generate')
+    .description('Generate migration files from schema changes')
+    .option('-m, --message <message>', 'Migration message', 'migration')
+    .action(async (opts: { message: string }) => {
+      let db
+      try {
+        const { db: database, registry, introspector } = await bootstrap()
+        db = database
+
+        console.log(chalk.cyan('Comparing 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)
+
+        const fileGen = new MigrationFileGenerator(MIGRATIONS_PATH)
+        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/cli/commands/migration_rollback.ts

@@ -0,0 +1,53 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { bootstrap, shutdown } from '../bootstrap.ts'
+import MigrationTracker from '../../database/migration/tracker.ts'
+import MigrationRunner from '../../database/migration/runner.ts'
+
+const MIGRATIONS_PATH = 'database/migrations'
+
+export function registerMigrationRollback(program: Command): void {
+  program
+    .command('migration:rollback')
+    .description('Rollback migrations by batch')
+    .option('--batch <number>', 'Specific batch number to rollback')
+    .action(async (opts: { batch?: string }) => {
+      let db
+      try {
+        const { db: database } = await bootstrap()
+        db = database
+
+        const tracker = new MigrationTracker(db)
+        const runner = new MigrationRunner(db, tracker, MIGRATIONS_PATH)
+
+        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/cli/commands/migration_run.ts

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

@@ -0,0 +1,35 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { bootstrap, shutdown } from '../bootstrap.ts'
+import Queue from '../../queue/queue.ts'
+
+export function registerQueueFlush(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/cli/commands/queue_retry.ts

@@ -0,0 +1,34 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { bootstrap, shutdown } from '../bootstrap.ts'
+import Queue from '../../queue/queue.ts'
+
+export function registerQueueRetry(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/cli/commands/queue_work.ts

@@ -0,0 +1,40 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { bootstrap, shutdown } from '../bootstrap.ts'
+import Queue from '../../queue/queue.ts'
+import Worker from '../../queue/worker.ts'
+
+export function registerQueueWork(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 => {
+      let db
+      try {
+        const { db: database, config } = await bootstrap()
+        db = database
+
+        new Queue(db, config)
+        await Queue.ensureTables()
+
+        const queue = options.queue
+        const sleep = parseInt(options.sleep)
+
+        console.log(chalk.cyan(`Worker starting on queue "${queue}"...`))
+        console.log(chalk.dim(`  poll interval: ${sleep}ms`))
+        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 (db) await shutdown(db)
+      }
+    })
+}

package/src/cli/commands/scheduler_work.ts

@@ -0,0 +1,45 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import path from 'node:path'
+import { bootstrap, shutdown } from '../bootstrap.ts'
+import Scheduler from '../../scheduler/scheduler.ts'
+import SchedulerRunner from '../../scheduler/runner.ts'
+
+export function registerSchedulerWork(program: Command): void {
+  program
+    .command('scheduler:work')
+    .description('Start the task scheduler')
+    .action(async () => {
+      let db
+      try {
+        const { db: database } = await bootstrap()
+        db = database
+
+        // Load user's scheduled tasks
+        const schedulesPath = path.resolve('app/schedules.ts')
+        await import(schedulesPath)
+
+        const taskCount = Scheduler.tasks.length
+        if (taskCount === 0) {
+          console.log(chalk.yellow('No tasks registered. Add tasks in app/schedules.ts'))
+          return
+        }
+
+        console.log(chalk.cyan(`Scheduler starting with ${taskCount} task(s)...`))
+        for (const task of Scheduler.tasks) {
+          console.log(chalk.dim(`  ${task.name}`))
+        }
+        console.log(chalk.dim('  Press Ctrl+C to stop.\n'))
+
+        const runner = new SchedulerRunner()
+        await runner.start()
+
+        console.log(chalk.dim('\nScheduler stopped.'))
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
+        process.exit(1)
+      } finally {
+        if (db) await shutdown(db)
+      }
+    })
+}

package/src/cli/strav.ts

@@ -0,0 +1,33 @@
+import 'reflect-metadata'
+import { Command } from 'commander'
+import { registerMigrationGenerate } from './commands/migration_generate.ts'
+import { registerMigrationRun } from './commands/migration_run.ts'
+import { registerMigrationRollback } from './commands/migration_rollback.ts'
+import { registerMigrationFresh } from './commands/migration_fresh.ts'
+import { registerMigrationCompare } from './commands/migration_compare.ts'
+import { registerGenerateModels } from './commands/generate_models.ts'
+import { registerQueueWork } from './commands/queue_work.ts'
+import { registerQueueRetry } from './commands/queue_retry.ts'
+import { registerQueueFlush } from './commands/queue_flush.ts'
+import { registerGenerateApi } from './commands/generate_api.ts'
+import { registerSchedulerWork } from './commands/scheduler_work.ts'
+import { registerGenerateKey } from './commands/generate_key.ts'
+
+const program = new Command()
+
+program.name('strav').description('Strav CLI').version('0.1.0')
+
+registerMigrationGenerate(program)
+registerMigrationRun(program)
+registerMigrationRollback(program)
+registerMigrationFresh(program)
+registerMigrationCompare(program)
+registerGenerateModels(program)
+registerQueueWork(program)
+registerQueueRetry(program)
+registerQueueFlush(program)
+registerGenerateApi(program)
+registerSchedulerWork(program)
+registerGenerateKey(program)
+
+program.parse()