spine-framework 0.1.60 → 0.2.0

package/.framework/cli/commands/install-app.ts

@@ -1,560 +0,0 @@
-/// <reference types="node" />
-/**
- * @module cli/commands/install-app
- * @audience installer
- * @layer cli
- * @stability stable
- *
- * `spine-framework install-app <slug>` — Install an app into the current Spine instance.
- *
- * Reads seed/*.json files from the app package directory and upserts their
- * contents into the database. Also registers the app in `app_installations`.
- *
- * **Seed file conventions:**
- * - `types.json` → upsert into `types` table
- * - `link-types.json` → upsert into `link_types` table
- * - `triggers.json` → upsert into `triggers` table
- * - `accounts.json` → upsert into `accounts` table
- * - `pipelines.json` → upsert into `pipelines` table
- *
- * All upserts keyed on `(app_id, slug)` — idempotent and safe to re-run.
- *
- * **Usage:**
- * ```bash
- * spine-framework install-app cortex
- * spine-framework install-app customer-portal
- * spine-framework install-app cortex --account <account-id>
- * ```
- */
-
-import type { Command } from 'commander'
-import { existsSync, readFileSync, readdirSync, cpSync, mkdirSync } from 'fs'
-import { resolve, dirname } from 'path'
-import { fileURLToPath } from 'url'
-import { execSync } from 'child_process'
-import { adminDb } from '../../functions/_shared/index.ts'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-const PROJECT_ROOT = process.cwd()
-
-interface InstallOptions {
-  account?: string
-  force: boolean
-  dryRun: boolean
-}
-
-interface SeedResult {
-  table: string
-  inserted: number
-  skipped: number
-  errors: string[]
-}
-
-async function resolveAppId(slug: string): Promise<string | null> {
-  const { data } = await adminDb
-    .from('apps')
-    .select('id')
-    .eq('slug', slug)
-    .single()
-
-  return data?.id || null
-}
-
-async function resolveSystemAccountId(): Promise<string | null> {
-  const { data } = await adminDb
-    .from('accounts')
-    .select('id')
-    .eq('slug', 'spine-system')
-    .maybeSingle()
-  return data?.id || null
-}
-
-async function ensureAppRecord(slug: string, name: string): Promise<string> {
-  let appId = await resolveAppId(slug)
-
-  if (!appId) {
-    const ownerAccountId = await resolveSystemAccountId()
-    const { error: insertErr, data } = await adminDb
-      .from('apps')
-      .insert({
-        slug,
-        name,
-        route_prefix: `/${slug}`,
-        renderer: 'custom',
-        is_active: true,
-        is_system: false,
-        owner_account_id: ownerAccountId,
-      })
-      .select('id')
-      .single()
-
-    if (insertErr) {
-      throw new Error(`Failed to create app record: ${insertErr.message}`)
-    }
-    appId = data.id
-    console.log(`  ✓ Created app record for '${slug}'`)
-  } else {
-    console.log(`  ⏭️  App '${slug}' already in database`)
-  }
-
-  return appId!
-}
-
-async function upsertTypes(appId: string, records: any[], dryRun: boolean): Promise<SeedResult> {
-  const result: SeedResult = { table: 'types', inserted: 0, skipped: 0, errors: [] }
-
-  for (const record of records) {
-    if (dryRun) {
-      console.log(`    [dry-run] Would upsert type: ${record.slug}`)
-      result.inserted++
-      continue
-    }
-
-    const { error } = await adminDb
-      .from('types')
-      .upsert({
-        ...record,
-        app_id: appId,
-      }, {
-        onConflict: 'app_id,kind,slug',
-        ignoreDuplicates: false
-      })
-
-    if (error) {
-      result.errors.push(`${record.slug}: ${error.message}`)
-    } else {
-      result.inserted++
-    }
-  }
-
-  return result
-}
-
-async function upsertLinkTypes(appId: string, records: any[], dryRun: boolean): Promise<SeedResult> {
-  const result: SeedResult = { table: 'link_types', inserted: 0, skipped: 0, errors: [] }
-
-  for (const record of records) {
-    if (dryRun) {
-      console.log(`    [dry-run] Would upsert link type: ${record.slug}`)
-      result.inserted++
-      continue
-    }
-
-    const { error } = await adminDb
-      .from('link_types')
-      .upsert({
-        ...record,
-        app_id: appId,
-      }, {
-        onConflict: 'app_id,slug',
-        ignoreDuplicates: false
-      })
-
-    if (error) {
-      result.errors.push(`${record.slug}: ${error.message}`)
-    } else {
-      result.inserted++
-    }
-  }
-
-  return result
-}
-
-async function upsertTriggers(appId: string, records: any[], dryRun: boolean): Promise<SeedResult> {
-  const result: SeedResult = { table: 'triggers', inserted: 0, skipped: 0, errors: [] }
-
-  for (const record of records) {
-    if (dryRun) {
-      console.log(`    [dry-run] Would upsert trigger: ${record.name}`)
-      result.inserted++
-      continue
-    }
-
-    // Clone config to avoid mutating the original
-    const config = record.config ? JSON.parse(JSON.stringify(record.config)) : {}
-
-    // Resolve type_slug references in filters to type_id
-    if (config.filters && Array.isArray(config.filters)) {
-      for (const filter of config.filters) {
-        if (filter.type_slug && !filter.value) {
-          const { data: typeData, error: typeError } = await adminDb
-            .from('types')
-            .select('id')
-            .eq('slug', filter.type_slug)
-            .eq('app_id', appId)
-            .single()
-
-          if (typeError || !typeData) {
-            result.errors.push(`${record.name}: type_slug '${filter.type_slug}' not found`)
-            continue
-          }
-
-          filter.value = typeData.id
-          delete filter.type_slug
-        }
-      }
-    }
-
-    const { error } = await adminDb
-      .from('triggers')
-      .upsert({
-        ...record,
-        app_id: appId,
-        config,
-      }, {
-        onConflict: 'app_id,name',
-        ignoreDuplicates: false
-      })
-
-    if (error) {
-      result.errors.push(`${record.name}: ${error.message}`)
-    } else {
-      result.inserted++
-    }
-  }
-
-  return result
-}
-
-async function upsertAccounts(appId: string, records: any[], dryRun: boolean): Promise<SeedResult> {
-  const result: SeedResult = { table: 'accounts', inserted: 0, skipped: 0, errors: [] }
-
-  for (const record of records) {
-    if (dryRun) {
-      console.log(`    [dry-run] Would upsert account: ${record.slug}`)
-      result.inserted++
-      continue
-    }
-
-    // Resolve type_slug → type_id if present
-    const row = { ...record, app_id: appId }
-    if (row.type_slug && !row.type_id) {
-      const { data: typeData } = await adminDb
-        .from('types')
-        .select('id')
-        .eq('kind', 'account')
-        .eq('slug', row.type_slug)
-        .limit(1)
-        .single()
-      if (typeData) {
-        row.type_id = typeData.id
-      } else {
-        result.errors.push(`${record.slug}: type_slug '${row.type_slug}' not found`)
-        continue
-      }
-      delete row.type_slug
-    }
-
-    const { error } = await adminDb
-      .from('accounts')
-      .upsert(row, {
-        onConflict: 'slug',
-        ignoreDuplicates: false
-      })
-
-    if (error) {
-      result.errors.push(`${record.slug}: ${error.message}`)
-    } else {
-      result.inserted++
-    }
-  }
-
-  return result
-}
-
-async function upsertPipelines(appId: string, records: any[], dryRun: boolean): Promise<SeedResult> {
-  const result: SeedResult = { table: 'pipelines', inserted: 0, skipped: 0, errors: [] }
-
-  for (const record of records) {
-    if (dryRun) {
-      console.log(`    [dry-run] Would upsert pipeline: ${record.slug}`)
-      result.inserted++
-      continue
-    }
-
-    const { error } = await adminDb
-      .from('pipelines')
-      .upsert({
-        ...record,
-        app_id: appId,
-      }, {
-        onConflict: 'app_id,name',
-        ignoreDuplicates: false
-      })
-
-    if (error) {
-      result.errors.push(`${record.slug}: ${error.message}`)
-    } else {
-      result.inserted++
-    }
-  }
-
-  return result
-}
-
-async function upsertRoles(appId: string, records: any[], dryRun: boolean): Promise<SeedResult> {
-  const result: SeedResult = { table: 'roles', inserted: 0, skipped: 0, errors: [] }
-
-  for (const record of records) {
-    if (dryRun) {
-      console.log(`    [dry-run] Would upsert role: ${record.slug}`)
-      result.inserted++
-      continue
-    }
-
-    const { error } = await adminDb
-      .from('roles')
-      .upsert({
-        ...record,
-        app_id: appId,
-      }, {
-        onConflict: 'app_id,slug',
-        ignoreDuplicates: false
-      })
-
-    if (error) {
-      result.errors.push(`${record.slug}: ${error.message}`)
-    } else {
-      result.inserted++
-    }
-  }
-
-  return result
-}
-
-const SEED_HANDLERS: Record<string, (appId: string, records: any[], dryRun: boolean) => Promise<SeedResult>> = {
-  'types.json': upsertTypes,
-  'link-types.json': upsertLinkTypes,
-  'triggers.json': upsertTriggers,
-  'accounts.json': upsertAccounts,
-  'pipelines.json': upsertPipelines,
-  'roles.json': upsertRoles,
-}
-
-async function recordInstallation(appSlug: string, accountId: string | null, dryRun: boolean): Promise<void> {
-  if (dryRun) {
-    console.log(`  [dry-run] Would record installation for '${appSlug}'`)
-    return
-  }
-
-  const { error } = await adminDb
-    .from('app_installations')
-    .upsert({
-      app_slug: appSlug,
-      account_id: accountId,
-      is_enabled: true,
-      updated_at: new Date().toISOString(),
-    }, {
-      onConflict: 'app_slug,account_id',
-    })
-
-  if (error) {
-    console.log(`  ⚠️  Failed to record installation: ${error.message}`)
-  }
-}
-
-function isNpmPackage(slug: string): boolean {
-  return slug.includes('/') || slug.startsWith('spine-framework-') || slug.startsWith('@')
-}
-
-function resolveSlugFromPackage(pkg: string): string {
-  const manifest = resolve(PROJECT_ROOT, `node_modules/${pkg}/spine-manifest.json`)
-  if (existsSync(manifest)) {
-    try {
-      return JSON.parse(readFileSync(manifest, 'utf8')).slug
-    } catch { /* fall through */ }
-  }
-  const pkgJson = resolve(PROJECT_ROOT, `node_modules/${pkg}/package.json`)
-  if (existsSync(pkgJson)) {
-    try {
-      const meta = JSON.parse(readFileSync(pkgJson, 'utf8'))
-      if (meta.spine?.slug) return meta.spine.slug
-    } catch { /* fall through */ }
-  }
-  return pkg.replace(/^spine-framework-/, '').replace(/^@[^/]+\//, '')
-}
-
-async function checkPrerequisites(_slug: string): Promise<void> {
-  // Apps are independently installable — no hardcoded prereqs.
-  // Future: read prereqs from the app's manifest.json if needed.
-}
-
-function copyAppFiles(pkg: string, slug: string): void {
-  const pkgDir = resolve(PROJECT_ROOT, `node_modules/${pkg}`)
-  const targetAppDir = resolve(PROJECT_ROOT, `custom/apps/${slug}`)
-
-  mkdirSync(targetAppDir, { recursive: true })
-
-  // Always copy core app files
-  const appFiles = ['index.tsx', 'manifest.json', 'package.json']
-  for (const file of appFiles) {
-    const src = resolve(pkgDir, file)
-    if (existsSync(src)) {
-      cpSync(src, resolve(targetAppDir, file), { force: true })
-    }
-  }
-
-  // Read directories from manifest (self-contained apps)
-  const manifestPath = resolve(pkgDir, 'manifest.json')
-  let appDirs = ['pages', 'components', 'hooks', 'config', 'seed', 'api', 'functions', 'migrations', 'tests']
-  
-  if (existsSync(manifestPath)) {
-    try {
-      const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'))
-      if (manifest.directories && Array.isArray(manifest.directories)) {
-        appDirs = manifest.directories
-      }
-    } catch (e) {
-      console.warn(`  ⚠️  Could not read manifest.json, using default directories`)
-    }
-  }
-
-  // Copy app directories (all self-contained within the app)
-  for (const dir of appDirs) {
-    const src = resolve(pkgDir, dir)
-    if (existsSync(src)) {
-      cpSync(src, resolve(targetAppDir, dir), { recursive: true, force: true })
-      console.log(`  ✓ Copied ${dir}/ → custom/apps/${slug}/${dir}/`)
-    }
-  }
-
-  console.log(`  ✓ Ejected app files → custom/apps/${slug}/`)
-}
-
-async function installApp(slug: string, options: InstallOptions): Promise<void> {
-  console.log(`\n📦 Installing app '${slug}'...\n`)
-
-  let resolvedSlug = slug
-  let packageName: string | null = null
-
-  if (isNpmPackage(slug)) {
-    // Strip version specifier (e.g. spine-framework-cortex@latest → spine-framework-cortex)
-    // Handles: pkg@latest, pkg@1.2.3, @scope/pkg@latest (preserve leading @ for scoped packages)
-    const barePackageName = slug.startsWith('@')
-      ? slug.replace(/(@[^/]+\/[^@]+)@.*$/, '$1')   // @scope/pkg@version → @scope/pkg
-      : slug.replace(/@.*$/, '')                      // pkg@version → pkg
-    packageName = barePackageName
-    console.log(`📥 Step 1: Installing npm package...`)
-    const pkgDir = resolve(PROJECT_ROOT, `node_modules/${barePackageName}`)
-    if (!existsSync(pkgDir)) {
-      try {
-        console.log(`  Running: npm install ${slug}`)
-        execSync(`npm install ${slug}`, { cwd: PROJECT_ROOT, stdio: 'inherit' })
-        console.log(`  ✓ Package installed`)
-      } catch (err: any) {
-        console.error(`  ❌ npm install failed: ${err.message}`)
-        process.exit(1)
-      }
-    } else {
-      console.log(`  ⏭️  Package already in node_modules`)
-    }
-    resolvedSlug = resolveSlugFromPackage(barePackageName)
-    console.log(`  ✓ App slug: ${resolvedSlug}`)
-
-    console.log(`\n📁 Step 2: Ejecting app files...`)
-    copyAppFiles(barePackageName, resolvedSlug)
-  }
-
-  // Check prerequisites (e.g. portal requires cortex)
-  await checkPrerequisites(resolvedSlug)
-
-  const appDir = resolve(PROJECT_ROOT, `custom/apps/${resolvedSlug}`)
-  if (!existsSync(appDir)) {
-    console.error(`  ❌ App directory not found: custom/apps/${resolvedSlug}`)
-    console.error(`     Install the npm package first or create the app with 'spine-framework create-app ${resolvedSlug}'`)
-    process.exit(1)
-  }
-
-  // 2. Read manifest for display name
-  const manifestPath = resolve(appDir, 'manifest.json')
-  let appName = slug
-  if (existsSync(manifestPath)) {
-    try {
-      const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'))
-      appName = manifest.name || slug
-      console.log(`  📋 Manifest: ${appName} v${manifest.version || '0.0.0'}`)
-    } catch {
-      console.log(`  ⚠️  Could not parse manifest.json, using slug as name`)
-    }
-  } else {
-    console.log(`  ⚠️  No manifest.json found, using slug as name`)
-  }
-
-  // 3. Ensure app record in DB
-  const appId = await ensureAppRecord(resolvedSlug, appName)
-
-  // 4. Process seed files
-  const seedDir = resolve(appDir, 'seed')
-  if (!existsSync(seedDir)) {
-    console.log(`  ⏭️  No seed/ directory — skipping data seeding`)
-  } else {
-    console.log(`\n🌱 Applying seed data...`)
-    const seedFiles = readdirSync(seedDir).filter(f => f.endsWith('.json'))
-
-    let totalInserted = 0
-    let totalErrors = 0
-
-    for (const file of seedFiles) {
-      const handler = SEED_HANDLERS[file]
-      if (!handler) {
-        console.log(`  ⏭️  Skipping unknown seed file: ${file}`)
-        continue
-      }
-
-      const filePath = resolve(seedDir, file)
-      let records: any[]
-      try {
-        records = JSON.parse(readFileSync(filePath, 'utf8'))
-        if (!Array.isArray(records)) {
-          console.log(`  ⚠️  ${file}: expected array, skipping`)
-          continue
-        }
-      } catch (err: any) {
-        console.error(`  ❌ ${file}: parse error — ${err.message}`)
-        continue
-      }
-
-      console.log(`  📄 ${file} (${records.length} records)...`)
-      const result = await handler(appId, records, options.dryRun)
-
-      if (result.errors.length > 0) {
-        for (const e of result.errors) {
-          console.error(`    ❌ ${e}`)
-        }
-        totalErrors += result.errors.length
-      }
-      totalInserted += result.inserted
-      console.log(`    ✓ ${result.inserted} upserted`)
-    }
-
-    console.log(`\n  Total: ${totalInserted} records upserted, ${totalErrors} errors`)
-  }
-
-  // 5. Record installation
-  console.log(`\n📝 Recording installation...`)
-  await recordInstallation(resolvedSlug, options.account || null, options.dryRun)
-
-  console.log(`\n✅ App '${appName}' installed successfully!`)
-  console.log(`\n   Next steps:`)
-  console.log(`   1. npm run assemble && netlify dev`)
-  console.log(`   2. Navigate to /${resolvedSlug} in your browser`)
-}
-
-export function registerInstallAppCommands(program: Command) {
-  program
-    .command('install-app <slug>')
-    .description('Install an app by applying its seed data to the database')
-    .option('--account <id>', 'Account ID to associate the installation with')
-    .option('--force', 'Overwrite existing seed data', false)
-    .option('--dry-run', 'Show what would happen without making changes', false)
-    .action(async (slug, opts) => {
-      try {
-        await installApp(slug, opts)
-      } catch (err: any) {
-        console.error('Error:', err.message)
-        if (process.env.SPINE_CLI_DEBUG) console.error(err.stack)
-        process.exit(1)
-      }
-    })
-}

package/.framework/cli/commands/migrate.ts

@@ -1,139 +0,0 @@
-/// <reference types="node" />
-/**
- * @module cli/commands/migrate
- * @audience installer
- * @layer cli
- * @stability stable
- *
- * `spine-framework migrate` — Apply SQL migrations to a Supabase project
- * via a direct Postgres connection.
- *
- * Requires --db-password (the Supabase database password).
- * Get it from: https://supabase.com/dashboard/project/_/settings/database
- *
- * **Usage:**
- * ```bash
- * spine-framework migrate --db-password <password>
- * spine-framework migrate --db-password <password> --dry-run
- * ```
- */
-
-import type { Command } from 'commander'
-import { existsSync, readdirSync, readFileSync } from 'fs'
-import { resolve, dirname } from 'path'
-import { fileURLToPath } from 'url'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-const MIGRATIONS_DIR = resolve(__dirname, '../../migrations')
-
-interface MigrateOptions {
-  dbPassword?: string
-  dryRun: boolean
-}
-
-async function migrateCommand(options: MigrateOptions): Promise<void> {
-  console.log('\n🗄️  Spine Framework — Migrate\n')
-
-  const supabaseUrl = process.env.SUPABASE_URL
-  if (!supabaseUrl || supabaseUrl === 'https://your-project.supabase.co') {
-    console.error('❌ SUPABASE_URL not set. Fill in your .env file first.')
-    process.exit(1)
-  }
-
-  const dbPassword = options.dbPassword || process.env.SUPABASE_DB_PASSWORD
-  if (!dbPassword || dbPassword === 'your-db-password') {
-    console.error('❌ SUPABASE_DB_PASSWORD not set.')
-    console.error('   Add it to .env or pass --db-password <password>')
-    console.error('   Get it from: https://supabase.com/dashboard/project/_/settings/database')
-    process.exit(1)
-  }
-
-  const projectRef = supabaseUrl.replace('https://', '').split('.')[0]
-  const connectionString = `postgresql://postgres:${dbPassword}@db.${projectRef}.supabase.co:5432/postgres`
-
-  if (!existsSync(MIGRATIONS_DIR)) {
-    console.error(`❌ Migrations directory not found: ${MIGRATIONS_DIR}`)
-    process.exit(1)
-  }
-
-  const files = readdirSync(MIGRATIONS_DIR)
-    .filter(f => f.endsWith('.sql'))
-    .sort()
-
-  if (files.length === 0) {
-    console.log('  No migration files found.')
-    return
-  }
-
-  console.log(`  Found ${files.length} migration file(s)\n`)
-
-  if (options.dryRun) {
-    for (const file of files) {
-      console.log(`  [dry-run] Would apply: ${file}`)
-    }
-    return
-  }
-
-  // Dynamically import pg to avoid loading it at module init time
-  const { default: pg } = await import('pg')
-  const client = new pg.Client({ connectionString })
-
-  try {
-    await client.connect()
-    console.log('  ✓ Connected to database\n')
-  } catch (err: any) {
-    console.error(`❌ Could not connect to database: ${err.message}`)
-    console.error('   Check your --db-password and that the project is active.')
-    process.exit(1)
-  }
-
-  let applied = 0
-  let failed = 0
-
-  for (const file of files) {
-    const sql = readFileSync(resolve(MIGRATIONS_DIR, file), 'utf8')
-    process.stdout.write(`  Applying ${file}... `)
-    try {
-      await client.query(sql)
-      console.log('✓')
-      applied++
-    } catch (err: any) {
-      console.log('❌')
-      console.error(`     ${err.message}`)
-      failed++
-      // Continue applying remaining migrations
-    }
-  }
-
-  await client.end()
-
-  console.log(`\n  ${applied} applied, ${failed} failed`)
-
-  if (failed > 0) {
-    console.error('\n❌ Some migrations failed. Check errors above.')
-    process.exit(1)
-  }
-
-  console.log('\n✅ All migrations applied successfully!')
-  console.log('\n   Next steps:')
-  console.log('   1. spine-framework install-app <app-slug>')
-  console.log('   2. npm run assemble && netlify dev')
-}
-
-export function registerMigrateCommands(program: Command) {
-  program
-    .command('migrate')
-    .description('Apply SQL migrations via direct Postgres connection')
-    .option('--db-password <password>', 'DB password override (default: reads SUPABASE_DB_PASSWORD from .env)')
-    .option('--dry-run', 'Show what would happen without making changes', false)
-    .action(async (opts) => {
-      try {
-        await migrateCommand(opts)
-      } catch (err: any) {
-        console.error('Error:', err.message)
-        if (process.env.SPINE_CLI_DEBUG) console.error(err.stack)
-        process.exit(1)
-      }
-    })
-}