@supatype/cli 0.1.0-alpha.10 → 0.1.0-alpha.12

package/src/commands/adopt.ts

@@ -0,0 +1,83 @@
+import type { Command } from "commander"
+import { createInterface } from "node:readline"
+import { loadConfig, loadSchemaAst } from "../config.js"
+import { schemaPathFromProject } from "../project-config.js"
+import { loadProjectLink } from "../link.js"
+import { resolveTarget, targetSchemaAdopt, schemaPgSchema } from "../resolve-target.js"
+
+interface AdoptPreview {
+  status: string
+  stampStatements?: string[]
+  doctor?: {
+    missing: unknown[]
+    staleManaged: unknown[]
+    unmanagedDrift: unknown[]
+  }
+}
+
+export function registerAdopt(program: Command): void {
+  program
+    .command("adopt")
+    .description("Stamp Supatype-managed comments on DB objects matching the schema (adoption ceremony)")
+    .option("--connection <url>", "Database connection URL (overrides config)")
+    .option("--env <name>", "Target environment when linked")
+    .option("--direct", "Use local engine subprocess")
+    .option("--yes", "Apply stamps without interactive confirmation")
+    .option("--no-cache", "Force full database introspection")
+    .action(async (opts: {
+      connection?: string
+      env?: string
+      direct?: boolean
+      yes?: boolean
+      noCache?: boolean
+    }) => {
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const pgSchema = schemaPgSchema(cwd)
+
+      console.log("Loading schema...")
+      const ast = loadSchemaAst(schemaPathFromProject(config, cwd), cwd)
+
+      const linked = loadProjectLink(cwd)
+      const target = linked && !opts.direct && !opts.connection
+        ? resolveTarget(cwd, { env: opts.env })
+        : resolveTarget(cwd, { env: opts.env, direct: true, connection: opts.connection })
+
+      const preview = (await targetSchemaAdopt(target, ast, {
+        schema: pgSchema,
+        noCache: opts.noCache ?? false,
+        yes: false,
+      })) as AdoptPreview
+
+      const statements = preview.stampStatements ?? []
+      if (statements.length === 0) {
+        console.log("Nothing to stamp — matching objects are already managed or absent.")
+        return
+      }
+
+      console.log(`\nWill stamp ${statements.length} object(s):\n`)
+      for (const sql of statements) {
+        console.log(`  ${sql}`)
+      }
+
+      if (!opts.yes) {
+        const rl = createInterface({ input: process.stdin, output: process.stdout })
+        const answer = await new Promise<string>((resolve) => {
+          rl.question("\nApply adoption stamps? [y/N] ", resolve)
+        })
+        rl.close()
+        if (!/^y(es)?$/i.test(answer.trim())) {
+          console.log("Adoption cancelled.")
+          return
+        }
+      }
+
+      const result = (await targetSchemaAdopt(target, ast, {
+        schema: pgSchema,
+        noCache: opts.noCache ?? false,
+        yes: true,
+      })) as { status: string; stamped?: number; name?: string }
+
+      console.log(`\nAdopted: ${result.stamped ?? 0} object(s) stamped (${result.name ?? "ok"}).`)
+    })
+}

package/src/commands/cloud.ts

@@ -2,19 +2,35 @@ import type { Command } from "commander"
 import { readFileSync, writeFileSync, existsSync } from "node:fs"
 import { resolve } from "node:path"
 import { createInterface } from "node:readline"
+import { loadProjectLink, migrateLegacyLinkFiles } from "../link.js"
+import { targetFetch } from "../target-client.js"
+import { registerEnvs, registerLinkOptions, runLinkAction } from "./link-helpers.js"
+import { resolveTarget, targetSchemaPush, schemaPgSchema } from "../resolve-target.js"
+import { loadConfig, loadSchemaAst } from "../config.js"
+import { schemaPathFromProject } from "../project-config.js"
 
 interface CloudConfig {
   apiUrl: string
   token: string
   projectSlug?: string
-  /** Organisation UUID — required for schema routes (`X-Org-Id`). */
-  orgId?: string
+  orgId?: string | undefined
 }
 
+/** @deprecated Prefer loadProjectLink */
 export function loadCloudConfig(cwd: string): CloudConfig | null {
-  const configPath = resolve(cwd, ".supatype/cloud.json")
-  if (!existsSync(configPath)) return null
-  return JSON.parse(readFileSync(configPath, "utf8")) as CloudConfig
+  migrateLegacyLinkFiles(cwd)
+  const link = loadProjectLink(cwd)
+  if (!link || link.kind !== "cloud") return null
+  const legacyPath = resolve(cwd, ".supatype/cloud.json")
+  if (existsSync(legacyPath)) {
+    return JSON.parse(readFileSync(legacyPath, "utf8")) as CloudConfig
+  }
+  return {
+    apiUrl: link.cloudApiUrl ?? "https://api.supatype.com",
+    token: link.token ?? "",
+    projectSlug: link.projectRef,
+    ...(link.orgId !== undefined ? { orgId: link.orgId } : {}),
+  }
 }
 
 function saveCloudConfig(cwd: string, config: CloudConfig): void {
@@ -27,135 +43,76 @@ function saveCloudConfig(cwd: string, config: CloudConfig): void {
 }
 
 async function cloudFetch<T>(config: CloudConfig, method: string, path: string, body?: unknown): Promise<T> {
-  const headers: Record<string, string> = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config.token}`,
-  }
-  if (config.orgId) {
-    headers["X-Org-Id"] = config.orgId
-  }
-  const res = await fetch(`${config.apiUrl}/api/v1${path}`, {
+  return targetFetch<T>(config.apiUrl, "/api/v1", {
     method,
-    headers,
-    ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+    path,
+    body,
+    token: config.token,
+    orgId: config.orgId,
   })
-
-  const json = await res.json() as { data?: T; error?: string; message?: string }
-  if (!res.ok) {
-    throw new Error(json.message ?? json.error ?? `API error: ${res.status}`)
-  }
-  return json.data as T
 }
 
-/** True when `.supatype/cloud.json` exists with a linked project slug. */
 export function isCloudLinked(cwd: string): boolean {
-  const cfg = loadCloudConfig(cwd)
-  return Boolean(cfg?.projectSlug && cfg.token)
+  migrateLegacyLinkFiles(cwd)
+  const link = loadProjectLink(cwd)
+  return Boolean(link?.kind === "cloud" && link.projectRef && link.token)
 }
 
-/**
- * Push schema AST to the linked cloud project (`POST /api/v1/projects/:ref/schema/push`).
- * Credentials stay server-side; only AST is sent.
- */
-export async function pushSchemaToLinkedProject(cwd: string, opts?: { force?: boolean }): Promise<void> {
-  const config = loadCloudConfig(cwd)
-  if (!config?.projectSlug) {
-    console.error("Not linked to a cloud project. Run: supatype link")
+export async function pushSchemaToLinkedProject(
+  cwd: string,
+  opts?: { force?: boolean; env?: string },
+): Promise<void> {
+  const config = loadConfig(cwd)
+  const target = resolveTarget(cwd, { env: opts?.env })
+  if (target.mode !== "cloud") {
+    console.error("Not linked to a cloud project. Run: supatype link --project <slug>")
     process.exit(1)
   }
-  if (!config.orgId) {
-    console.error(
-      "Missing orgId in .supatype/cloud.json. Re-run: supatype link --project <slug> (after cloud login).",
-    )
-    process.exit(1)
-  }
-
-  const { loadConfig: loadAppConfig, loadSchemaAst } = await import("../config.js")
-  const { schemaPathFromProject } = await import("../project-config.js")
 
-  const appConfig = loadAppConfig(cwd)
-  const ast = loadSchemaAst(schemaPathFromProject(appConfig, cwd), cwd)
+  const ast = loadSchemaAst(schemaPathFromProject(config, cwd), cwd)
+  console.log(`Pushing schema to ${target.mode} project ${target.projectRef} (${target.environment})...`)
 
-  console.log(`Pushing schema to cloud project ${config.projectSlug}...`)
-
-  const result = await cloudFetch<{ message?: string }>(config, "POST", `/projects/${config.projectSlug}/schema/push`, {
-    ast,
+  const result = await targetSchemaPush(target, ast, {
     force: opts?.force ?? true,
+    schema: schemaPgSchema(cwd),
   })
 
-  console.log(result.message ?? "Schema push completed.")
+  console.log((result as { message?: string }).message ?? "Schema push completed.")
 }
 
-/** @deprecated Use pushSchemaToLinkedProject — kept for deploy command alias */
-export async function deploySchemaToLinkedProject(cwd: string, _environment: string): Promise<void> {
-  await pushSchemaToLinkedProject(cwd)
+export async function deploySchemaToLinkedProject(cwd: string, environment: string): Promise<void> {
+  await pushSchemaToLinkedProject(cwd, { force: true, env: environment })
 }
 
 function prompt(question: string): Promise<string> {
   const rl = createInterface({ input: process.stdin, output: process.stdout })
-  return new Promise((resolve) => {
+  return new Promise((resolvePrompt) => {
     rl.question(question, (answer) => {
       rl.close()
-      resolve(answer.trim())
+      resolvePrompt(answer.trim())
     })
   })
 }
 
-// ─── Registration ──────────────────────────────────────────────────────────────
-
 export function registerCloud(program: Command): void {
-  // ── Link ───────────────────────────────────────────────────────────────────
-  program
-    .command("link")
-    .description("Link this local project to a Supatype cloud project")
-    .option("--project <slug>", "Project slug to link to")
-    .option("--api-url <url>", "Control plane API URL", "https://api.supatype.com")
-    .option("--token <token>", "Authentication token")
-    .action(async (opts: { project?: string; apiUrl: string; token?: string }) => {
-      const cwd = process.cwd()
-      const token = opts.token ?? process.env["SUPATYPE_TOKEN"]
-      if (!token) {
-        console.error("Authentication required. Set SUPATYPE_TOKEN or pass --token.")
-        process.exit(1)
-      }
-
-      const config: CloudConfig = { apiUrl: opts.apiUrl, token }
-
-      if (opts.project) {
-        config.projectSlug = opts.project
-        const one = await cloudFetch<{ slug: string; orgId: string }>(config, "GET", `/projects/${opts.project}`)
-        config.orgId = one.orgId
-      } else {
-        const projects = await cloudFetch<Array<{ slug: string; name: string; status: string; tier: string; orgId: string }>>(
-          config, "GET", "/projects",
-        )
-        if (projects.length === 0) {
-          console.error("No projects found. Create one with: supatype projects create <name>")
-          process.exit(1)
-        }
-
-        console.log("\nAvailable projects:\n")
-        projects.forEach((p, i) => {
-          console.log(`  ${i + 1}. ${p.name} (${p.slug}) [${p.tier}] — ${p.status}`)
-        })
-
-        const answer = await prompt(`\nSelect project (1-${projects.length}): `)
-        const idx = parseInt(answer, 10) - 1
-        if (isNaN(idx) || idx < 0 || idx >= projects.length) {
-          console.error("Invalid selection.")
-          process.exit(1)
-        }
-        const picked = projects[idx]!
-        config.projectSlug = picked.slug
-        config.orgId = picked.orgId
-      }
+  registerEnvs(program)
 
-      saveCloudConfig(cwd, config)
-      console.log(`\nLinked to project: ${config.projectSlug}`)
-      console.log(`Config saved to .supatype/cloud.json\n`)
-    })
+  const linkCmd = program
+    .command("link")
+    .description("Link this project to cloud or self-host (unified .supatype/link.json)")
+  registerLinkOptions(linkCmd)
+  linkCmd.action(async (opts: {
+    project?: string
+    url?: string
+    apiUrl: string
+    token?: string
+    serviceRoleKey?: string
+    env?: string
+    fixGitignore?: boolean
+  }) => {
+    await runLinkAction(opts)
+  })
 
-  // ── Projects ───────────────────────────────────────────────────────────────
   const projectsCmd = program
     .command("projects")
     .description("Manage cloud projects")
@@ -223,7 +180,6 @@ export function registerCloud(program: Command): void {
       console.log(`Project ${slug} resumed.`)
     })
 
-  // ── Domains ────────────────────────────────────────────────────────────────
   const domainsCmd = program
     .command("domains")
     .description("Manage custom domains for a project")
@@ -313,10 +269,12 @@ function getCloudConfigOrExit(): CloudConfig {
   const cwd = process.cwd()
   let config = loadCloudConfig(cwd)
   if (!config) {
-    const token = process.env["SUPATYPE_TOKEN"]
+    const token =
+      process.env["SUPATYPE_ACCESS_TOKEN"] ??
+      process.env["SUPATYPE_TOKEN"]
     const apiUrl = process.env["SUPATYPE_API_URL"] ?? "https://api.supatype.com"
     if (!token) {
-      console.error("Not connected to Supatype Cloud. Run: supatype link, or set SUPATYPE_TOKEN.")
+      console.error("Not connected to Supatype Cloud. Run: supatype link, or set SUPATYPE_ACCESS_TOKEN.")
       process.exit(1)
     }
     config = { apiUrl, token }

package/src/commands/db.ts

@@ -7,14 +7,15 @@
 import type { Command } from "commander"
 import { loadConfig } from "../config.js"
 import { connectionString } from "../project-config.js"
-import { loadCloudConfig } from "./cloud.js"
+import { loadProjectLink } from "../link.js"
+import { resolveTarget } from "../resolve-target.js"
+import { targetFetch } from "../target-client.js"
 
 export function registerDb(program: Command): void {
   const db = program
     .command("db")
     .description("Database connection management")
 
-  // supatype db connection-string
   db
     .command("connection-string")
     .description("Show the database connection string for the linked project")
@@ -23,11 +24,10 @@ export function registerDb(program: Command): void {
     .action(async (opts: { transaction?: boolean; env?: string }) => {
       const cwd = process.cwd()
       const config = loadConfig(cwd)
-      const cloudCfg = loadCloudConfig(cwd)
+      const link = loadProjectLink(cwd)
       const localConn = connectionString(config)
 
-      // If no cloud project linked, show the local connection string.
-      if (!cloudCfg?.projectSlug) {
+      if (!link || link.kind !== "cloud") {
         const connStr = opts.transaction ? localConn.replace(/:5432\//, ":6432/") : localConn
         console.log(connStr)
         console.log()
@@ -36,30 +36,22 @@ export function registerDb(program: Command): void {
         return
       }
 
-      // If linked to a cloud project, fetch from the API
-      const apiUrl = cloudCfg.apiUrl || "https://api.supatype.com"
-      const token = cloudCfg.token || process.env["SUPATYPE_ACCESS_TOKEN"] || ""
+      const target = resolveTarget(cwd, { env: opts.env })
       const envName = opts.env || "production"
 
       try {
-        const res = await fetch(
-          `${apiUrl}/platform/v1/projects/${cloudCfg.projectSlug}/environments`,
+        const data = await targetFetch<Array<{ name: string; databaseUrl?: string }>>(
+          target.apiBaseUrl,
+          target.apiPrefix,
           {
-            headers: {
-              Authorization: `Bearer ${token}`,
-            },
+            method: "GET",
+            path: `/projects/${target.projectRef}/environments`,
+            token: target.token!,
+            orgId: target.orgId,
           },
         )
 
-        if (!res.ok) {
-          console.error(`Failed to fetch project info: ${res.status}`)
-          process.exitCode = 1
-          return
-        }
-
-        const { data } = (await res.json()) as { data: Array<{ name: string; databaseUrl?: string }> }
         const env = data.find((e) => e.name === envName)
-
         if (!env) {
           console.error(`Environment "${envName}" not found`)
           process.exitCode = 1
@@ -67,12 +59,7 @@ export function registerDb(program: Command): void {
         }
 
         const connStr = env.databaseUrl || "Connection string not available"
-        if (opts.transaction) {
-          console.log(connStr.replace(/:5432\//, ":6432/"))
-        } else {
-          console.log(connStr)
-        }
-
+        console.log(opts.transaction ? connStr.replace(/:5432\//, ":6432/") : connStr)
         console.log()
         console.log("Session mode (port 5432): for interactive tools (psql, DataGrip, TablePlus)")
         console.log("Transaction mode (port 6432): for application servers and serverless functions")
@@ -82,52 +69,41 @@ export function registerDb(program: Command): void {
       }
     })
 
-  // supatype db reset-password
   db
     .command("reset-password")
     .description("Reset the database password for the linked project")
     .option("--env <name>", "Environment name", "production")
     .action(async (opts: { env?: string }) => {
       const cwd = process.cwd()
-      const cloudCfg = loadCloudConfig(cwd)
+      const link = loadProjectLink(cwd)
 
-      if (!cloudCfg?.projectSlug) {
+      if (!link || link.kind !== "cloud") {
         console.error("Not linked to a cloud project. Run: supatype link --project <ref>")
         process.exitCode = 1
         return
       }
 
-      const apiUrl = cloudCfg.apiUrl || "https://api.supatype.com"
-      const token = cloudCfg.token || process.env["SUPATYPE_ACCESS_TOKEN"] || ""
+      const target = resolveTarget(cwd, { env: opts.env })
       const envName = opts.env || "production"
 
       try {
-        const res = await fetch(
-          `${apiUrl}/platform/v1/projects/${cloudCfg.projectSlug}/environments/${envName}/reset-db-password`,
+        const data = await targetFetch<{ password?: string; databaseUrl?: string }>(
+          target.apiBaseUrl,
+          target.apiPrefix,
           {
             method: "POST",
-            headers: {
-              Authorization: `Bearer ${token}`,
-              "Content-Type": "application/json",
-            },
+            path: `/projects/${target.projectRef}/environments/${envName}/reset-db-password`,
+            token: target.token!,
+            orgId: target.orgId,
           },
         )
 
-        if (!res.ok) {
-          const body = await res.text()
-          console.error(`Failed to reset password: ${res.status} ${body}`)
-          process.exitCode = 1
-          return
-        }
-
-        const { data } = (await res.json()) as { data: { password: string; connectionString: string } }
         console.log("Database password reset successfully.")
-        console.log()
-        console.log(`New password: ${data.password}`)
-        console.log(`Connection string: ${data.connectionString}`)
-        console.log()
-        console.log("Warning: Existing database connections have been terminated.")
-        console.log("Update your application with the new connection string.")
+        if (data.databaseUrl) {
+          console.log(`\nNew connection string:\n${data.databaseUrl}`)
+        } else if (data.password) {
+          console.log(`\nNew password: ${data.password}`)
+        }
       } catch (err) {
         console.error("Failed to reset password:", (err as Error).message)
         process.exitCode = 1