@supatype/cli 0.1.0-alpha.9 → 0.1.1

package/src/commands/deploy.ts

@@ -12,15 +12,20 @@
  */
 
 import type { Command } from "commander"
-import { existsSync, readdirSync, statSync, createReadStream } from "node:fs"
-import { join } from "node:path"
+import { existsSync, readdirSync, statSync, createReadStream, mkdirSync, cpSync } from "node:fs"
+import { join, relative } from "node:path"
 import { loadConfig, loadSchemaAst } from "../config.js"
 import { connectionString, schemaPathFromProject } from "../project-config.js"
 import { deploySchemaToLinkedProject, loadCloudConfig, pushSchemaToLinkedProject } from "./cloud.js"
+import { loadProjectLink } from "../link.js"
+import { resolveTarget } from "../resolve-target.js"
+import { targetFetch } from "../target-client.js"
 import { ensureEngine, engineRequest, type DiffResult } from "../engine-client.js"
 import { resolveAppConfig, validateStaticMode, validateBuildOutput, detectPackageManager } from "../app/framework.js"
 import { TIER_LIMITS, type Tier } from "./deploy-types.js"
 import { spawnSync } from "node:child_process"
+import { error, info, plain, step, warn } from "../ui/messages.js"
+import { withSpinner } from "../ui/progress.js"
 
 export function registerDeploy(program: Command): void {
   const deploy = program
@@ -29,7 +34,8 @@ export function registerDeploy(program: Command): void {
       "Deploy schema and app — Supatype Cloud by default when linked (`supatype link`); pass --local for engine + your database",
     )
     .option("--local", "Use local schema engine and database_url from config (skip cloud control plane)")
-    .option("--environment <name>", "Cloud environment when using linked project", "production")
+    .option("--environment <name>", "Target environment when linked", "production")
+    .option("--env <name>", "Alias for --environment")
     .option("--app-only", "Skip schema push, only deploy the static site")
     .option("--schema-only", "Skip app build, only push schema changes")
     .option("--skip-build", "Deploy existing build output without building")
@@ -38,6 +44,7 @@ export function registerDeploy(program: Command): void {
     .action(async (opts: {
       local?: boolean
       environment?: string
+      env?: string
       appOnly?: boolean
       schemaOnly?: boolean
       skipBuild?: boolean
@@ -46,18 +53,19 @@ export function registerDeploy(program: Command): void {
     }) => {
       const cwd = process.cwd()
       const config = loadConfig(cwd)
+      const link = loadProjectLink(cwd)
       const cloudCfg = loadCloudConfig(cwd)
+      const envName = opts.env ?? opts.environment ?? "production"
 
       let schemaDone = false
 
-      // Default: cloud — .supatype/cloud.json → control plane schema deploy
       if (
         !opts.local &&
-        cloudCfg?.projectSlug &&
+        link &&
         !opts.appOnly &&
         !opts.skipBuild
       ) {
-        await deploySchemaToLinkedProject(cwd, opts.environment ?? "production")
+        await deploySchemaToLinkedProject(cwd, envName)
         schemaDone = true
         if (opts.schemaOnly) {
           return
@@ -69,7 +77,7 @@ export function registerDeploy(program: Command): void {
         const ast = loadSchemaAst(schemaPathFromProject(config, cwd), cwd)
 
         if (opts.local) {
-          console.log("=== Schema Push (local) ===")
+          step("Schema Push (local)")
           await ensureEngine()
 
           const diff = await engineRequest<DiffResult>("/diff", {
@@ -81,22 +89,22 @@ export function registerDeploy(program: Command): void {
           const ops = diff.operations ?? []
 
           if (ops.length > 0) {
-            console.log(`${ops.length} schema change(s) to apply.`)
+            info(`${ops.length} schema change(s) to apply.`)
             await engineRequest("/push", {
               ast,
               database_url: connectionString(config),
               schema: "public",
               force: true,
             })
-            console.log("Schema changes applied.")
+            info("Schema changes applied.")
           } else {
-            console.log("Schema is up to date.")
+            info("Schema is up to date.")
           }
-        } else if (cloudCfg?.projectSlug) {
-          console.log("=== Schema Push (cloud) ===")
-          await pushSchemaToLinkedProject(cwd, { force: opts.yes ?? true })
+        } else if (link) {
+          step("Schema Push (linked)")
+          await pushSchemaToLinkedProject(cwd, { force: opts.yes ?? true, env: envName })
         } else {
-          console.error(
+          error(
             "Not linked to Supatype Cloud. Run: supatype link\n" +
               "Or deploy against your own database: supatype deploy --local",
           )
@@ -108,29 +116,29 @@ export function registerDeploy(program: Command): void {
       if (!opts.schemaOnly) {
         if (!config.build) {
           if (opts.appOnly) {
-            console.error("No build section found in supatype.config.ts")
+            error("No build section found in supatype.config.ts")
             process.exit(1)
           }
           // No build config — skip app deployment silently
           return
         }
 
-        console.log("\n=== App Build & Deploy ===")
+        step("App Build & Deploy")
         const appConfig = resolveAppConfig(config.build, cwd)
 
         // Validate static mode
         const staticError = validateStaticMode(appConfig.framework, appConfig.directory)
         if (staticError) {
-          console.error(staticError)
+          error(staticError)
           process.exit(1)
         }
 
         // Build step
         if (!opts.skipBuild && appConfig.buildCommand) {
-          console.log(`Framework: ${appConfig.framework}`)
-          console.log(`Build command: ${appConfig.buildCommand}`)
-          console.log(`Output directory: ${appConfig.outputDirectory}`)
-          console.log()
+          info(`Framework: ${appConfig.framework}`)
+          info(`Build command: ${appConfig.buildCommand}`)
+          info(`Output directory: ${appConfig.outputDirectory}`)
+          plain()
 
           // Inject environment variables
           const buildEnv: Record<string, string> = {
@@ -148,7 +156,7 @@ export function registerDeploy(program: Command): void {
 
           // Install dependencies
           const pm = detectPackageManager(appConfig.directory)
-          console.log(`Installing dependencies (${pm})...`)
+          info(`Installing dependencies (${pm})...`)
           const installResult = spawnSync(pm, ["install"], {
             cwd: appConfig.directory,
             stdio: "inherit",
@@ -156,12 +164,12 @@ export function registerDeploy(program: Command): void {
             timeout: 5 * 60 * 1000, // 5 minute timeout
           })
           if (installResult.status !== 0) {
-            console.error("Dependency installation failed.")
+            error("Dependency installation failed.")
             process.exit(1)
           }
 
           // Run build
-          console.log("\nBuilding...")
+          plain("\nBuilding...")
           const [buildCmd, ...buildArgs] = appConfig.buildCommand.split(" ")
           const buildResult = spawnSync(buildCmd!, buildArgs, {
             cwd: appConfig.directory,
@@ -170,7 +178,7 @@ export function registerDeploy(program: Command): void {
             timeout: 10 * 60 * 1000, // 10 minute timeout
           })
           if (buildResult.status !== 0) {
-            console.error("Build failed.")
+            error("Build failed.")
             process.exit(1)
           }
         }
@@ -179,27 +187,27 @@ export function registerDeploy(program: Command): void {
         const maxSizeMb = 500 // Default, should be tier-aware in cloud
         const validationError = validateBuildOutput(appConfig.outputDirectory, maxSizeMb)
         if (validationError) {
-          console.error(validationError)
+          error(validationError)
           process.exit(1)
         }
 
         // Deploy (--local never uploads to cloud, even if linked)
-        if (cloudCfg?.projectSlug && !opts.local) {
-          await deployToCloud(
-            { projectRef: cloudCfg.projectSlug, apiUrl: cloudCfg.apiUrl, accessToken: cloudCfg.token },
-            appConfig.outputDirectory,
-            opts.preview ?? false,
-          )
+        if (link && !opts.local) {
+          await deployStaticSite(cwd, appConfig.outputDirectory, {
+            preview: opts.preview ?? false,
+            env: envName,
+          })
         } else {
           deploySelfHost(appConfig.outputDirectory, cwd)
         }
 
-        console.log("\nDeployment complete!")
-        if (cloudCfg?.projectSlug && !opts.local) {
+        info("Deployment complete!")
+        if (link && !opts.local) {
+          const target = resolveTarget(cwd, { env: envName })
           const url = opts.preview
-            ? `https://preview-${Date.now().toString(36)}.${cloudCfg.projectSlug}.supatype.dev`
-            : `https://${cloudCfg.projectSlug}.supatype.dev`
-          console.log(`URL: ${url}`)
+            ? `${target.apiBaseUrl}/preview`
+            : target.apiBaseUrl
+          info(`URL: ${url}`)
         }
       }
     })
@@ -208,123 +216,174 @@ export function registerDeploy(program: Command): void {
   deploy
     .command("rollback")
     .description("Roll back to the previous static site deployment")
-    .action(async () => {
-      const cloudCfg = loadCloudConfig(process.cwd())
-      if (!cloudCfg?.projectSlug) {
-        console.error("Not linked to a cloud project. Rollback is only available for cloud deployments.")
-        process.exit(1)
-      }
-
-      const apiUrl = cloudCfg.apiUrl || "https://api.supatype.com"
-      const token = cloudCfg.token || process.env["SUPATYPE_ACCESS_TOKEN"] || ""
-
-      const res = await fetch(`${apiUrl}/platform/v1/projects/${cloudCfg.projectSlug}/deployments/rollback`, {
-        method: "POST",
-        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
-      })
-
-      if (!res.ok) {
-        const body = await res.text()
-        console.error(`Rollback failed: ${res.status} ${body}`)
+    .option("--env <name>", "Target environment when linked")
+    .option("--to <id>", "Roll back to a specific deployment id or version")
+    .action(async (opts: { env?: string; to?: string }) => {
+      const cwd = process.cwd()
+      const link = loadProjectLink(cwd)
+      if (!link) {
+        error("Not linked to a project. Rollback requires a linked target.")
         process.exit(1)
       }
 
-      const { data } = await res.json() as { data: { version: string; message: string } }
-      console.log(`Rolled back to deployment ${data.version}.`)
+      const target = resolveTarget(cwd, { env: opts.env })
+      const body = opts.to ? { to: opts.to } : undefined
+      const data = await targetFetch<{ version: string; message: string }>(
+        target.apiBaseUrl,
+        target.apiPrefix,
+        {
+          method: "POST",
+          path: `/projects/${target.projectRef}/deployments/rollback`,
+          body,
+          token: target.token!,
+          orgId: target.orgId,
+          environment: target.mode === "cloud" ? target.environment : undefined,
+        },
+      )
+
+      info(`Rolled back to deployment ${data.version ?? "previous"}.`)
     })
 
   // supatype deploy status
   deploy
     .command("status")
     .description("Show current deployment status")
-    .action(async () => {
-      const cloudCfg = loadCloudConfig(process.cwd())
-      if (!cloudCfg?.projectSlug) {
-        console.error("Not linked to a cloud project.")
+    .option("--env <name>", "Target environment when linked")
+    .action(async (opts: { env?: string }) => {
+      const cwd = process.cwd()
+      const link = loadProjectLink(cwd)
+      if (!link) {
+        error("Not linked to a project.")
         process.exit(1)
       }
 
-      const apiUrl = cloudCfg.apiUrl || "https://api.supatype.com"
-      const token = cloudCfg.token || process.env["SUPATYPE_ACCESS_TOKEN"] || ""
-
-      const res = await fetch(`${apiUrl}/platform/v1/projects/${cloudCfg.projectSlug}/deployments/current`, {
-        headers: { Authorization: `Bearer ${token}` },
-      })
-
-      if (!res.ok) {
-        console.error("No active deployment found.")
+      const target = resolveTarget(cwd, { env: opts.env })
+      const data = await targetFetch<{
+        version?: string
+        id?: string
+        timestamp?: string
+        createdAt?: string
+        size?: number
+        buildDuration?: number
+        url?: string
+        status?: string
+      } | null>(
+        target.apiBaseUrl,
+        target.apiPrefix,
+        {
+          method: "GET",
+          path: `/projects/${target.projectRef}/deployments/current`,
+          token: target.token!,
+          orgId: target.orgId,
+          environment: target.mode === "cloud" ? target.environment : undefined,
+        },
+      )
+
+      if (!data) {
+        info("No active deployment found.")
         return
       }
 
-      const { data } = await res.json() as { data: {
-        version: string
-        timestamp: string
-        size: number
-        buildDuration: number
-        url: string
-        status: string
-      }}
-
-      console.log(`Deployment: ${data.version}`)
-      console.log(`Status: ${data.status}`)
-      console.log(`Deployed: ${data.timestamp}`)
-      console.log(`Size: ${(data.size / (1024 * 1024)).toFixed(1)}MB`)
-      console.log(`Build duration: ${data.buildDuration}s`)
-      console.log(`URL: ${data.url}`)
+      info(`Deployment: ${data.version ?? data.id ?? "unknown"}`)
+      info(`Status: ${data.status ?? "live"}`)
+      if (data.timestamp ?? data.createdAt) {
+        info(`Deployed: ${data.timestamp ?? data.createdAt}`)
+      }
+      if (data.size) info(`Size: ${(data.size / (1024 * 1024)).toFixed(1)}MB`)
+      if (data.buildDuration) info(`Build duration: ${data.buildDuration}s`)
+      if (data.url) info(`URL: ${data.url}`)
     })
 
   // supatype deploy logs <version>
   deploy
     .command("logs [version]")
     .description("Show build logs for a deployment")
-    .action(async (version?: string) => {
-      const cloudCfg = loadCloudConfig(process.cwd())
-      if (!cloudCfg?.projectSlug) {
-        console.error("Not linked to a cloud project.")
+    .option("--env <name>", "Target environment when linked")
+    .action(async (version: string | undefined, opts: { env?: string }) => {
+      const cwd = process.cwd()
+      const link = loadProjectLink(cwd)
+      if (!link) {
+        error("Not linked to a project.")
         process.exit(1)
       }
 
-      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 versionPath = version ? `/${version}` : "/current"
-      const res = await fetch(`${apiUrl}/platform/v1/projects/${cloudCfg.projectSlug}/deployments${versionPath}/logs`, {
-        headers: { Authorization: `Bearer ${token}` },
-      })
-
-      if (!res.ok) {
-        console.error("Logs not found.")
-        process.exit(1)
-      }
-
-      const { data } = await res.json() as { data: { logs: string } }
-      console.log(data.logs)
+      const data = await targetFetch<{ logs: string }>(
+        target.apiBaseUrl,
+        target.apiPrefix,
+        {
+          method: "GET",
+          path: `/projects/${target.projectRef}/deployments${versionPath}/logs`,
+          token: target.token!,
+          orgId: target.orgId,
+          environment: target.mode === "cloud" ? target.environment : undefined,
+        },
+      )
+
+      plain(data.logs ?? "(no logs)")
     })
 }
 
-async function deployToCloud(
-  config: { projectRef?: string; apiUrl?: string; accessToken?: string },
+async function deployStaticSite(
+  cwd: string,
   outputDir: string,
-  isPreview: boolean,
+  opts: { preview?: boolean; env?: string },
 ): Promise<void> {
-  const apiUrl = config.apiUrl || "https://api.supatype.com"
-  const token = config.accessToken || process.env["SUPATYPE_ACCESS_TOKEN"] || ""
-
-  console.log("Uploading build artifacts...")
+  const target = resolveTarget(cwd, { env: opts.env })
+  const token = target.token
+  if (!token) {
+    throw new Error("No token for linked target. Re-run supatype link --token ...")
+  }
 
-  // Collect files from output directory
+  info("Uploading build artifacts...")
   const files = collectFiles(outputDir, outputDir)
-  console.log(`${files.length} files to upload (${formatSize(files.reduce((s, f) => s + f.size, 0))})`)
+  info(`${files.length} files to upload (${formatSize(files.reduce((s, f) => s + f.size, 0))})`)
+
+  const { readFileSync } = await import("node:fs")
+
+  if (target.apiPrefix === "/platform/v1") {
+    const filePayload = files.map((f) => ({
+      path: f.relativePath,
+      content: readFileSync(f.absolutePath).toString("base64"),
+      encoding: "base64",
+    }))
+
+    const created = await targetFetch<{ id: string }>(
+      target.apiBaseUrl,
+      target.apiPrefix,
+      {
+        method: "POST",
+        path: `/projects/${target.projectRef}/deployments`,
+        body: { preview: opts.preview ?? false, files: filePayload },
+        token,
+        orgId: target.orgId,
+      },
+    )
+
+    await targetFetch(
+      target.apiBaseUrl,
+      target.apiPrefix,
+      {
+        method: "POST",
+        path: `/projects/${target.projectRef}/deployments/${created.id}/finalize`,
+        token,
+        orgId: target.orgId,
+      },
+    )
+    return
+  }
 
-  // Create deployment
-  const createRes = await fetch(`${apiUrl}/platform/v1/projects/${config.projectRef}/deployments`, {
+  const createRes = await fetch(`${target.apiBaseUrl}/api/v1/projects/${target.projectRef}/deployments`, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${token}`,
       "Content-Type": "application/json",
+      ...(target.orgId ? { "X-Org-Id": target.orgId } : {}),
+      ...(target.environment ? { "X-Supatype-Environment": target.environment } : {}),
     },
     body: JSON.stringify({
-      preview: isPreview,
+      preview: opts.preview ?? false,
       fileCount: files.length,
       totalSize: files.reduce((s, f) => s + f.size, 0),
       files: files.map((f) => ({ path: f.relativePath, size: f.size })),
@@ -338,9 +397,8 @@ async function deployToCloud(
 
   const { data } = await createRes.json() as { data: { deploymentId: string; uploadUrl: string } }
 
-  // Upload files (simplified — in production, use multipart or presigned URLs)
   for (const file of files) {
-    const content = require("node:fs").readFileSync(file.absolutePath)
+    const content = readFileSync(file.absolutePath)
     await fetch(`${data.uploadUrl}/${file.relativePath}`, {
       method: "PUT",
       headers: {
@@ -352,19 +410,23 @@ async function deployToCloud(
     })
   }
 
-  // Finalize deployment
-  await fetch(`${apiUrl}/platform/v1/projects/${config.projectRef}/deployments/${data.deploymentId}/finalize`, {
-    method: "POST",
-    headers: { Authorization: `Bearer ${token}` },
-  })
+  await fetch(
+    `${target.apiBaseUrl}/api/v1/projects/${target.projectRef}/deployments/${data.deploymentId}/finalize`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        ...(target.orgId ? { "X-Org-Id": target.orgId } : {}),
+      },
+    },
+  )
 }
 
 function deploySelfHost(outputDir: string, cwd: string): void {
   const servingDir = join(cwd, ".supatype", "static")
-  const { mkdirSync, cpSync } = require("node:fs") as typeof import("node:fs")
   mkdirSync(servingDir, { recursive: true })
   cpSync(outputDir, servingDir, { recursive: true })
-  console.log(`Static files deployed to ${servingDir}`)
+  info(`Static files deployed to ${servingDir}`)
 }
 
 interface FileEntry {
@@ -375,8 +437,6 @@ interface FileEntry {
 
 function collectFiles(dir: string, baseDir: string): FileEntry[] {
   const files: FileEntry[] = []
-  const { readdirSync, statSync } = require("node:fs") as typeof import("node:fs")
-  const { relative } = require("node:path") as typeof import("node:path")
 
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
     const fullPath = join(dir, entry.name)