@strav/cli 0.3.33 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strav/cli",
-  "version": "0.3.33",
+  "version": "0.4.0",
   "type": "module",
   "description": "CLI framework and code generators for the Strav framework",
   "license": "MIT",
@@ -33,11 +33,11 @@
     "strav": "./src/cli/strav.ts"
   },
   "peerDependencies": {
-    "@strav/kernel": "0.3.33",
-    "@strav/http": "0.3.33",
-    "@strav/database": "0.3.33",
-    "@strav/queue": "0.3.33",
-    "@strav/signal": "0.3.33"
+    "@strav/kernel": "0.4.0",
+    "@strav/http": "0.4.0",
+    "@strav/database": "0.4.0",
+    "@strav/queue": "0.4.0",
+    "@strav/signal": "0.4.0"
   },
   "dependencies": {
     "chalk": "^5.6.2",

package/src/cli/bootstrap.ts

@@ -4,7 +4,6 @@ import SchemaRegistry from '@strav/database/schema/registry'
 import DatabaseIntrospector from '@strav/database/database/introspector'
 import Application from '@strav/kernel/core/application'
 import type ServiceProvider from '@strav/kernel/core/service_provider'
-import { discoverDomains } from '@strav/database'
 import { getDatabasePaths } from '../config/loader.ts'
 
 export interface BootstrapResult {
@@ -19,32 +18,16 @@ export interface BootstrapResult {
  *
  * Loads configuration, connects to the database, discovers and validates
  * schemas, and creates an introspector instance.
- *
- * @param scope - Optional domain to discover schemas from (e.g., 'public', 'tenant', 'factory')
  */
-export async function bootstrap(scope?: string): Promise<BootstrapResult> {
+export async function bootstrap(): Promise<BootstrapResult> {
   const config = new Configuration('./config')
   await config.load()
 
   const db = new Database(config)
 
   const registry = new SchemaRegistry()
-
-  // Get the configured database paths
   const dbPaths = await getDatabasePaths()
-
-  if (scope && scope !== 'public') {
-    // For non-public domains, we need to load public schemas first since they may reference them
-    await registry.discover(dbPaths.schemas, 'public')
-    await registry.discover(dbPaths.schemas, scope)
-  } else if (scope === 'public') {
-    // For public schemas, only load public
-    await registry.discover(dbPaths.schemas, 'public')
-  } else {
-    // Default: discover all schemas (backward compatibility)
-    await registry.discover(dbPaths.schemas)
-  }
-
+  await registry.discover(dbPaths.schemas)
   registry.validate()
 
   const introspector = new DatabaseIntrospector(db)

package/src/commands/db_setup_roles.ts

@@ -0,0 +1,91 @@
+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}";`,
+          `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}";`,
+        ]
+
+        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_models.ts

@@ -1,10 +1,7 @@
-import { join } from 'node:path'
 import type { Command } from 'commander'
 import chalk from 'chalk'
 import SchemaRegistry from '@strav/database/schema/registry'
 import ModelGenerator from '../generators/model_generator.ts'
-import type { GeneratorConfig } from '../generators/config.ts'
-import { discoverDomains } from '@strav/database'
 import { loadGeneratorConfig, getDatabasePaths } from '../config/loader.ts'
 
 export function register(program: Command): void {
@@ -12,101 +9,28 @@ export function register(program: Command): void {
     .command('generate:models')
     .alias('g:models')
     .description('Generate model classes and enums from schema definitions')
-    .option('--scope <scope>', 'Generate models for specific domain or "all" for all domains', 'all')
-    .action(async (options) => {
+    .action(async () => {
       try {
-        const scope = options.scope as string
-
-        // Get configured database paths
         const dbPaths = await getDatabasePaths()
-
-        // Validate scope against available domains or 'all'
-        const availableDomains = discoverDomains(dbPaths.schemas)
-        if (scope !== 'all' && !availableDomains.includes(scope)) {
-          console.error(chalk.red(`Invalid domain: ${scope}. Available domains: ${availableDomains.join(', ')}, all`))
-          process.exit(1)
-        }
-
-        console.log(chalk.cyan(`Generating models from ${scope === 'all' ? 'all' : scope} schemas...`))
-
-        // Load generator config (if available)
         const config = await loadGeneratorConfig()
 
-        const allFiles: any[] = []
-        const scopesToProcess = scope === 'all' ? availableDomains : [scope]
-
-        // When generating models for specific domains, we need all schemas loaded
-        // to handle cross-domain references properly
-        const fullRegistry = new SchemaRegistry()
-
-        // Always load public schemas first (base schemas)
-        await fullRegistry.discover(dbPaths.schemas, 'public')
-
-        // Load schemas from all other domains if needed for validation or if generating models for those domains
-        for (const domain of availableDomains) {
-          if (domain !== 'public' && (scope === 'all' || scope === domain)) {
-            await fullRegistry.discover(dbPaths.schemas, domain)
-          }
-        }
+        console.log(chalk.cyan('Generating models from schemas...'))
 
-        // Validate all loaded schemas
-        fullRegistry.validate()
+        const registry = new SchemaRegistry()
+        await registry.discover(dbPaths.schemas)
+        registry.validate()
 
-        // Build representation from all loaded schemas
-        const fullRepresentation = fullRegistry.buildRepresentation()
-
-        // Build a map of schema name -> domain for cross-domain reference resolution
-        const allSchemasMap = new Map<string, string>()
-
-        // Load public schemas to identify which ones are public
-        const publicRegistry = new SchemaRegistry()
-        await publicRegistry.discover(dbPaths.schemas, 'public')
-        const publicSchemaNames = new Set(publicRegistry.all().map(s => s.name))
-
-        // Map schemas to their respective domains by checking which domain directory they came from
-        for (const schema of fullRegistry.all()) {
-          if (publicSchemaNames.has(schema.name)) {
-            allSchemasMap.set(schema.name, 'public')
-          } else {
-            // For non-public schemas, find which domain they belong to
-            // by checking which domains were loaded
-            for (const domain of availableDomains) {
-              if (domain !== 'public') {
-                const domainRegistry = new SchemaRegistry()
-                await domainRegistry.discover(dbPaths.schemas, domain)
-                const domainSchemaNames = new Set(domainRegistry.all().map(s => s.name))
-                if (domainSchemaNames.has(schema.name)) {
-                  allSchemasMap.set(schema.name, domain)
-                  break
-                }
-              }
-            }
-          }
-        }
-
-        for (const currentScope of scopesToProcess) {
-          // Get just the schemas for the current scope
-          const scopeRegistry = new SchemaRegistry()
-          await scopeRegistry.discover(dbPaths.schemas, currentScope)
-
-          if (scopeRegistry.all().length === 0) {
-            console.log(chalk.yellow(`No schemas found for domain: ${currentScope}`))
-            continue
-          }
-
-          const scopeSchemas = scopeRegistry.all()
-          const generator = new ModelGenerator(scopeSchemas, fullRepresentation, config, currentScope, allSchemasMap)
-          const files = await generator.writeAll()
-          allFiles.push(...files)
-        }
+        const representation = registry.buildRepresentation()
+        const generator = new ModelGenerator(registry.all(), representation, config)
+        const files = await generator.writeAll()
 
-        if (allFiles.length === 0) {
+        if (files.length === 0) {
           console.log(chalk.yellow('No models to generate.'))
           return
         }
 
-        console.log(chalk.green(`\nGenerated ${allFiles.length} file(s):`))
-        for (const file of allFiles) {
+        console.log(chalk.green(`\nGenerated ${files.length} file(s):`))
+        for (const file of files) {
           console.log(chalk.dim(`  ${file.path}`))
         }
       } catch (err) {

package/src/commands/migration_fresh.ts

@@ -11,7 +11,6 @@ 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 { discoverDomains } from '@strav/database'
 import { getDatabasePaths } from '../config/loader.ts'
 
 /**
@@ -24,37 +23,34 @@ export async function freshDatabase(
   db: Database,
   registry: SchemaRegistry,
   introspector: DatabaseIntrospector,
-  migrationsPath: string = 'database/migrations',
-  scope: string = 'public'
+  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`
+  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) {
-    await db.sql.unsafe(`DROP TABLE IF EXISTS "${row.table_name}" CASCADE`)
+  `)
+  for (const row of tables as Array<{ table_name: string }>) {
+    await conn.unsafe(`DROP TABLE IF EXISTS "${row.table_name}" CASCADE`)
   }
 
-  // Drop all enum types in public schema
-  const types = await db.sql`
+  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) {
-    await db.sql.unsafe(`DROP TYPE IF EXISTS "${row.typname}" CASCADE`)
+  `)
+  for (const row of types as Array<{ typname: string }>) {
+    await conn.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()
@@ -68,11 +64,10 @@ export async function freshDatabase(
   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, scope)
-  const runner = new MigrationRunner(db, tracker, migrationsPath, scope)
+  const tracker = new MigrationTracker(db)
+  const runner = new MigrationRunner(db, tracker, migrationsPath)
   const result = await runner.run()
 
   return result.applied.length
@@ -101,8 +96,7 @@ export function register(program: Command): void {
     .command('fresh')
     .alias('migration:fresh')
     .description('Reset database and migrations, regenerate and run from scratch')
-    .option('-s, --scope <scope>', 'Domain (e.g., public, tenant, factory, marketing)', 'public')
-    .action(async (opts: { scope: string }) => {
+    .action(async () => {
       requireLocalEnv('fresh')
 
       // 6-digit challenge
@@ -123,22 +117,11 @@ export function register(program: Command): void {
 
       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)
+        const { db: database, registry, introspector } = await bootstrap()
         db = database
 
-        // Use scoped migrations path
-        const scopedPath = `${dbPaths.migrations}/${scope}`
-        const applied = await freshDatabase(db, registry, introspector, scopedPath, scope)
+        const applied = await freshDatabase(db, registry, introspector, dbPaths.migrations)
 
         console.log(chalk.green(`\nFresh migration complete. Applied ${applied} migration(s).`))
       } catch (err) {

package/src/commands/migration_generate.ts

@@ -4,7 +4,6 @@ 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 { discoverDomains } from '@strav/database'
 import { getDatabasePaths } from '../config/loader.ts'
 
 export function register(program: Command): void {
@@ -13,24 +12,14 @@ export function register(program: Command): void {
     .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 }) => {
+    .action(async (opts: { message: 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)
+        const { db: database, registry, introspector } = await bootstrap()
         db = database
 
-        console.log(chalk.cyan(`Comparing ${scope} schema with database...`))
+        console.log(chalk.cyan('Comparing schema with database...'))
 
         const desired = registry.buildRepresentation()
         const actual = await introspector.introspect()
@@ -49,16 +38,11 @@ export function register(program: Command): void {
 
         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 fileGen = new MigrationFileGenerator(dbPaths.migrations)
         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`))

package/src/commands/migration_rollback.ts

@@ -3,7 +3,6 @@ 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 { discoverDomains } from '@strav/database'
 import { getDatabasePaths } from '../config/loader.ts'
 
 export function register(program: Command): void {
@@ -12,26 +11,15 @@ export function register(program: Command): void {
     .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 }) => {
+    .action(async (opts: { batch?: 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 tracker = new MigrationTracker(db)
+        const runner = new MigrationRunner(db, tracker, dbPaths.migrations)
 
         const batchNum = opts.batch ? parseInt(opts.batch, 10) : undefined
 

package/src/commands/migration_run.ts

@@ -3,7 +3,6 @@ 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 { discoverDomains } from '@strav/database'
 import { getDatabasePaths } from '../config/loader.ts'
 
 export function register(program: Command): void {
@@ -11,26 +10,15 @@ export function register(program: Command): void {
     .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 }) => {
+    .action(async () => {
       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 tracker = new MigrationTracker(db)
+        const runner = new MigrationRunner(db, tracker, dbPaths.migrations)
 
         console.log(chalk.cyan('Running pending migrations...'))
 

package/src/commands/tenant_create.ts

@@ -0,0 +1,35 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { bootstrap, shutdown } from '../cli/bootstrap.ts'
+import TenantManager from '@strav/database/database/tenant/manager'
+import { ensureTenantTable } from '@strav/database/database/tenant/seed'
+
+export function register(program: Command): void {
+  program
+    .command('tenant:create')
+    .description('Create a new tenant')
+    .requiredOption('--slug <slug>', 'Unique tenant slug (used for subdomain/URLs)')
+    .requiredOption('--name <name>', 'Tenant display name')
+    .action(async (opts: { slug: string; name: string }) => {
+      let db
+      try {
+        const { db: database } = await bootstrap()
+        db = database
+
+        await ensureTenantTable(db.bypass)
+        const manager = new TenantManager(db)
+
+        const tenant = await manager.create({ slug: opts.slug, name: opts.name })
+
+        console.log(chalk.green('\nTenant created:'))
+        console.log(chalk.dim(`  id:   ${tenant.id}`))
+        console.log(chalk.dim(`  slug: ${tenant.slug}`))
+        console.log(chalk.dim(`  name: ${tenant.name}`))
+      } 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/tenant_delete.ts

@@ -0,0 +1,64 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { createInterface } from 'node:readline'
+import { bootstrap, shutdown } from '../cli/bootstrap.ts'
+import TenantManager from '@strav/database/database/tenant/manager'
+import { ensureTenantTable } from '@strav/database/database/tenant/seed'
+
+export function register(program: Command): void {
+  program
+    .command('tenant:delete <id>')
+    .description('Delete a tenant and cascade-delete all their rows')
+    .option('-f, --force', 'Skip the confirmation prompt')
+    .action(async (id: string, opts: { force?: boolean }) => {
+      let db
+      try {
+        const { db: database } = await bootstrap()
+        db = database
+
+        await ensureTenantTable(db.bypass)
+        const manager = new TenantManager(db)
+
+        const tenant = await manager.find(id)
+        if (!tenant) {
+          console.error(chalk.red(`Tenant not found: ${id}`))
+          process.exit(1)
+        }
+
+        if (!opts.force) {
+          console.log(
+            chalk.red('WARNING: ') +
+              `This will delete tenant "${tenant.slug}" and ` +
+              chalk.red('cascade-delete all their data') +
+              ' across every tenant-scoped table.'
+          )
+          const challenge = tenant.slug
+          console.log(`\n  Type ${chalk.yellow(challenge)} to confirm:\n`)
+
+          const answer = await prompt('  > ')
+          if (answer.trim() !== challenge) {
+            console.error(chalk.red('\nConfirmation does not match. Operation cancelled.'))
+            process.exit(1)
+          }
+        }
+
+        await manager.delete(id)
+        console.log(chalk.green(`\nTenant "${tenant.slug}" deleted.`))
+      } 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/tenant_list.ts

@@ -0,0 +1,39 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import { bootstrap, shutdown } from '../cli/bootstrap.ts'
+import TenantManager from '@strav/database/database/tenant/manager'
+import { ensureTenantTable } from '@strav/database/database/tenant/seed'
+
+export function register(program: Command): void {
+  program
+    .command('tenant:list')
+    .description('List all tenants')
+    .action(async () => {
+      let db
+      try {
+        const { db: database } = await bootstrap()
+        db = database
+
+        await ensureTenantTable(db.bypass)
+        const manager = new TenantManager(db)
+        const tenants = await manager.list()
+
+        if (tenants.length === 0) {
+          console.log(chalk.yellow('No tenants found.'))
+          return
+        }
+
+        console.log(chalk.cyan(`\n${tenants.length} tenant(s):\n`))
+        for (const t of tenants) {
+          console.log(`  ${chalk.green(t.slug)}`)
+          console.log(chalk.dim(`    id:   ${t.id}`))
+          console.log(chalk.dim(`    name: ${t.name}`))
+        }
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err instanceof Error ? err.message : err}`))
+        process.exit(1)
+      } finally {
+        if (db) await shutdown(db)
+      }
+    })
+}

package/src/config/loader.ts

@@ -10,30 +10,23 @@ export async function loadGeneratorConfig(): Promise<GeneratorConfig | undefined
   try {
     return (await import(join(process.cwd(), 'config/generators.ts'))).default
   } catch {
-    // No config/generators.ts — use defaults
     return undefined
   }
 }
 
 /**
  * Get the fully resolved database paths from the configuration.
- * This includes the schemas and migrations paths with defaults.
  */
 export async function getDatabasePaths(): Promise<{ schemas: string; migrations: string }> {
   const config = await loadGeneratorConfig()
   const paths = resolvePaths(config)
-
-  return {
-    schemas: paths.schemas,
-    migrations: paths.migrations,
-  }
+  return { schemas: paths.schemas, migrations: paths.migrations }
 }
 
 /**
  * Get all resolved paths from the configuration.
- * Useful for commands that need multiple paths.
  */
-export async function getAllPaths(scope?: string): Promise<GeneratorPaths> {
+export async function getAllPaths(): Promise<GeneratorPaths> {
   const config = await loadGeneratorConfig()
-  return resolvePaths(config, scope)
-}
+  return resolvePaths(config)
+}

package/src/generators/config.ts

@@ -22,13 +22,8 @@ export interface GeneratorPaths {
   migrations: string
 }
 
-export interface ModelNaming {
-  [domain: string]: string | null | undefined
-}
-
 export interface GeneratorConfig {
   paths?: Partial<GeneratorPaths>
-  modelNaming?: ModelNaming
 }
 
 // ---------------------------------------------------------------------------
@@ -47,7 +42,6 @@ const DEFAULT_PATHS: GeneratorPaths = {
   routes: 'start',
   tests: 'tests/api',
   docs: 'public/_docs',
-  // Database paths
   schemas: 'database/schemas',
   migrations: 'database/migrations',
 }
@@ -57,19 +51,8 @@ const DEFAULT_PATHS: GeneratorPaths = {
 // ---------------------------------------------------------------------------
 
 /** Merge user config with defaults, returning fully resolved paths. */
-export function resolvePaths(config?: GeneratorConfig, scope?: string): GeneratorPaths {
-  const basePaths = config?.paths ? { ...DEFAULT_PATHS, ...config.paths } : { ...DEFAULT_PATHS }
-
-  // If a domain is provided, append it to models and enums paths
-  if (scope) {
-    return {
-      ...basePaths,
-      models: `${basePaths.models}/${scope}`,
-      enums: `${basePaths.enums}/${scope}`
-    }
-  }
-
-  return basePaths
+export function resolvePaths(config?: GeneratorConfig): GeneratorPaths {
+  return config?.paths ? { ...DEFAULT_PATHS, ...config.paths } : { ...DEFAULT_PATHS }
 }
 
 /**
@@ -79,34 +62,13 @@ export function resolvePaths(config?: GeneratorConfig, scope?: string): Generato
  */
 export function relativeImport(fromDir: string, toDir: string): string {
   let rel = relative(fromDir, toDir)
-  // Normalize Windows separators for import paths
   rel = rel.split('\\').join('/')
   return rel.startsWith('.') ? rel : './' + rel
 }
 
-/** Get the model name prefix for a given domain. Returns empty string if no prefix. */
-export function getModelPrefix(config: GeneratorConfig | undefined, domain: string | undefined): string {
-  if (!domain) return ''
-
-  // Public domain has no prefix by default
-  if (domain === 'public') {
-    return config?.modelNaming?.[domain] ?? ''
-  }
-
-  // For other domains, use configured prefix or default to PascalCase
-  if (config?.modelNaming?.[domain] !== undefined) {
-    return config.modelNaming[domain] || ''
-  }
-
-  // Default prefix: PascalCase the domain name
-  return domain.charAt(0).toUpperCase() + domain.slice(1).toLowerCase()
-}
-
 /**
  * Format generated files with Prettier and write them to disk.
- * Resolves the Prettier config from each file's location (so the project's
- * `.prettierrc` is picked up automatically). Falls back to writing
- * unformatted content if Prettier is not installed.
+ * Falls back to writing unformatted content if Prettier is not installed.
  */
 export async function formatAndWrite(files: GeneratedFile[]): Promise<void> {
   let prettier: typeof import('prettier') | null = null

package/src/generators/model_generator.ts

@@ -10,7 +10,7 @@ import type {
 import type { PostgreSQLCustomType } from '@strav/database/schema/postgres'
 import { toSnakeCase, toCamelCase, toPascalCase } from '@strav/kernel/helpers/strings'
 import type { GeneratorConfig, GeneratorPaths } from './config.ts'
-import { resolvePaths, relativeImport, formatAndWrite, getModelPrefix } from './config.ts'
+import { resolvePaths, relativeImport, formatAndWrite } from './config.ts'
 
 export interface GeneratedFile {
   path: string
@@ -20,19 +20,15 @@ export interface GeneratedFile {
 export default class ModelGenerator {
   private schemaMap: Map<string, SchemaDefinition>
   private paths: GeneratorPaths
-  private modelPrefix: string
   private config?: GeneratorConfig
 
   constructor(
     private schemas: SchemaDefinition[],
     private representation: DatabaseRepresentation,
-    config?: GeneratorConfig,
-    private domain?: string,
-    private allSchemasMap?: Map<string, string>
+    config?: GeneratorConfig
   ) {
     this.schemaMap = new Map(schemas.map(s => [s.name, s]))
-    this.paths = resolvePaths(config, domain)
-    this.modelPrefix = getModelPrefix(config, domain)
+    this.paths = resolvePaths(config)
     this.config = config
   }
 
@@ -299,7 +295,7 @@ export default class ModelGenerator {
     lines.push('// Generated by Strav — DO NOT EDIT')
     lines.push(...importLines)
     lines.push('')
-    lines.push(`export default class ${this.prefixClassName(className)} extends BaseModel {`)
+    lines.push(`export default class ${(className)} extends BaseModel {`)
 
     if (hasSoftDeletes) {
       lines.push('  static override softDeletes = true')
@@ -560,7 +556,7 @@ export default class ModelGenerator {
       if (mode === 'named') {
         lines.push(`export * from './${basename}'`)
       } else {
-        const className = this.prefixClassName(toPascalCase(basename))
+        const className = (toPascalCase(basename))
         lines.push(`export { default as ${className} } from './${basename}'`)
       }
     }
@@ -577,29 +573,9 @@ export default class ModelGenerator {
   // Helpers
   // ---------------------------------------------------------------------------
 
-  /** Apply model name prefix to a class name. */
-  private prefixClassName(className: string): string {
-    return `${this.modelPrefix}${className}`
-  }
-
-  /** Apply appropriate prefix to a model name based on which domain it belongs to. */
+  /** Convert a schema name to its generated model class name. */
   private prefixModelName(modelName: string): string {
-    // If we don't have domain mapping, use current domain prefix
-    if (!this.allSchemasMap) {
-      return this.prefixClassName(toPascalCase(modelName))
-    }
-
-    // Check which domain this model belongs to
-    const modelDomain = this.allSchemasMap.get(modelName)
-
-    if (modelDomain) {
-      // Get the appropriate prefix for that domain
-      const prefix = getModelPrefix(this.config, modelDomain)
-      return `${prefix}${toPascalCase(modelName)}`
-    }
-
-    // Fallback to current domain prefix
-    return this.prefixClassName(toPascalCase(modelName))
+    return toPascalCase(modelName)
   }
 
   private isForeignKey(columnName: string, table: TableDefinition): boolean {