@supatype/cli 0.1.0-alpha.9 → 0.1.1

package/src/commands/update.ts

@@ -8,8 +8,10 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs"
 import { basename, resolve } from "node:path"
 import { loadConfig } from "../config.js"
 import { resolveRuntimeProvider } from "../project-config.js"
-import { runDockerCompose, writeSelfHostCompose } from "../self-host-compose.js"
-import { download, currentPlatform, fetchAllLatestVersions, type Component } from "../binary-cache.js"
+import { runDockerCompose, writeSelfHostCompose, composePullNeedsIgnoreFailures, composeProjectName, exitComposeFailed } from "../self-host-compose.js"
+import { syncComposeImagePins } from "../dev-compose.js"
+import { download, currentPlatform, fetchAllLatestVersions, pinnedVersion, type Component } from "../binary-cache.js"
+import { error, info, plain } from "../ui/messages.js"
 
 const CONFIG_CANDIDATES = ["supatype.config.ts", "supatype.config.js", "supatype.config.mjs"]
 
@@ -35,14 +37,23 @@ export function registerUpdate(program: Command): void {
 
       if (provider === "docker") {
         if (opts.check) {
-          console.log("Docker provider: run without --check to pull compose images (supatype self-host compose pull).")
+          info("Docker provider: run without --check to pull compose images (supatype self-host compose pull).")
           return
         }
         const paths = writeSelfHostCompose(cwd, config, { devLocal: true })
-        console.log("Pulling self-host compose images...")
-        const status = runDockerCompose(paths.composePath, ["pull"], cwd)
-        if (status !== 0) process.exit(status)
-        console.log("Compose images updated.")
+        syncComposeImagePins(cwd, config)
+        info("Pulling self-host compose images...")
+        const pullArgs = ["pull"]
+        if (composePullNeedsIgnoreFailures(config, cwd)) {
+          pullArgs.push("--ignore-pull-failures")
+        }
+        const brand = { intro: "Update components" }
+        const project = composeProjectName(config.project.name)
+        const status = runDockerCompose(paths.composePath, pullArgs, cwd, project, { brand })
+        if (status !== 0) {
+          exitComposeFailed(status, "Could not pull Compose images.", brand)
+        }
+        info("Compose images updated.")
         return
       }
 
@@ -51,59 +62,84 @@ export function registerUpdate(program: Command): void {
       const components: Component[] = ["engine", "server", "postgres", "deno"]
       const updates: Array<{ component: Component; from: string; to: string }> = []
 
-      console.log("Fetching latest component versions from CDN...")
+      info("Fetching latest component versions from CDN...")
       const latestVersions = await fetchAllLatestVersions()
 
       for (const component of components) {
-        const current = config.versions[component]
-        if (current === "local") continue
         const latest = latestVersions[component]
+        const current = pinnedVersion(component, config)
+        if (!current) {
+          if (opts.check) {
+            plain(`  ${component}  (latest) → ${latest} on CDN`)
+          } else {
+            info(`Downloading latest ${component} v${latest}...`)
+            try {
+              await download(component, latest, platform)
+              info(`${component} v${latest} downloaded.`)
+            } catch (err) {
+              error(`Failed: ${(err as Error).message}`)
+            }
+          }
+          continue
+        }
+        if (current === "local") continue
         if (current !== latest) {
           updates.push({ component, from: current, to: latest })
         }
       }
 
       if (updates.length === 0) {
-        console.log("All components are up to date.")
+        info(opts.check ? "All pinned components match CDN latest." : "All components are up to date.")
         return
       }
 
-      console.log("Available updates:")
+      plain("Available updates:")
       for (const { component, from, to } of updates) {
-        console.log(`  ${component}  ${from} → ${to}`)
+        plain(`  ${component}  ${from} → ${to}`)
       }
 
       if (opts.check) return
 
       // Download updated binaries.
       for (const { component, to } of updates) {
-        console.log(`\nDownloading ${component} v${to}...`)
+        info(`Downloading ${component} v${to}...`)
         try {
           await download(component, to, platform)
         } catch (err) {
-          console.error(`  Failed: ${(err as Error).message}`)
+          error(`Failed: ${(err as Error).message}`)
           continue
         }
-        console.log(`  ${component} v${to} downloaded.`)
+        info(`${component} v${to} downloaded.`)
       }
 
       const configPath = resolveConfigFile(cwd)
       if (configPath === null) {
-        console.error("No supatype.config.ts (or .js/.mjs) found to patch versions.")
+        error("No supatype.config.ts (or .js/.mjs) found to patch versions.")
         process.exit(1)
       }
 
       let text = readFileSync(configPath, "utf8")
       for (const { component, to } of updates) {
         const key = component
-        // engine: "0.4.1"  or  engine: '0.4.1'
-        text = text.replace(
-          new RegExp(`(${key}\\s*:\\s*['"])[^'"]*(['"])`),
-          `$1${to}$2`,
-        )
+        if (text.includes(`${key}:`)) {
+          text = text.replace(
+            new RegExp(`(${key}\\s*:\\s*['"])[^'"]*(['"])`),
+            `$1${to}$2`,
+          )
+        } else if (text.includes("versions:")) {
+          text = text.replace(
+            /(versions:\s*\{[^}]*)(\})/,
+            `$1,\n    ${key}: "${to}"$2`,
+          )
+        } else {
+          text = text.replace(
+            /(\n)(\s*)(email:|schema:|storage:)/,
+            `$1$2versions: {\n$2  ${key}: "${to}",\n$2},\n$2$3`,
+          )
+        }
       }
 
       writeFileSync(configPath, text, "utf8")
-      console.log(`\n${basename(configPath)} updated.`)
+      info(`${basename(configPath)} updated.`)
     })
 }

package/src/compose-rename.ts

@@ -0,0 +1,76 @@
+/**
+ * Detect and clean up Docker Compose state when `project.name` changes.
+ */
+
+import { existsSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import * as p from "@clack/prompts"
+import { loadLocalEnvironment } from "./link.js"
+import { composeStackHasContainers } from "./dev-session-lock.js"
+import { composeProjectName, runDockerCompose, type SelfHostComposePaths } from "./self-host-compose.js"
+import { isInteractive } from "./ui/interactive.js"
+import { warn } from "./ui/messages.js"
+
+/**
+ * When `project.name` changes, the compose project slug changes too (`supatype-{name}`).
+ * Offer to stop containers from the previous slug so volumes/ports do not linger.
+ */
+export async function handleComposeProjectRename(
+  cwd: string,
+  currentProjectName: string,
+  paths: SelfHostComposePaths,
+): Promise<void> {
+  const local = loadLocalEnvironment(cwd)
+  const previousRef = local?.projectRef?.trim()
+  if (!previousRef || previousRef === currentProjectName) return
+
+  const previousCompose = composeProjectName(previousRef)
+  const currentCompose = composeProjectName(currentProjectName)
+  if (previousCompose === currentCompose) return
+  if (!composeStackHasContainers(previousCompose)) return
+
+  const message =
+    `Project renamed from "${previousRef}" to "${currentProjectName}".\n` +
+    `Docker stack "${previousCompose}" may still be running.`
+
+  if (!isInteractive()) {
+    warn(message)
+    warn(`Stop it manually: docker compose -p ${previousCompose} down`)
+    return
+  }
+
+  const stopOld = await p.confirm({
+    message: `${message}\n\nStop the old Docker stack now?`,
+    initialValue: true,
+  })
+
+  if (p.isCancel(stopOld) || !stopOld) {
+    warn(`Leaving "${previousCompose}" running. Stop it with: docker compose -p ${previousCompose} down`)
+    return
+  }
+
+  const status = runDockerCompose(paths.composePath, ["down"], cwd, previousCompose, { quiet: true })
+  if (status === 0) {
+    p.log.success(`Stopped old stack "${previousCompose}".`)
+    warnIfHardcodedComposeScripts(cwd, previousCompose)
+  } else {
+    warn(`Could not stop "${previousCompose}" (exit ${status}). Try: docker compose -p ${previousCompose} down`)
+  }
+}
+
+function warnIfHardcodedComposeScripts(cwd: string, oldComposeProject: string): void {
+  const pkgPath = join(cwd, "package.json")
+  if (!existsSync(pkgPath)) return
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as { scripts?: Record<string, string> }
+    const scripts = Object.values(pkg.scripts ?? {}).join("\n")
+    if (scripts.includes(`-p ${oldComposeProject}`)) {
+      warn(
+        `package.json scripts still reference compose project "${oldComposeProject}". ` +
+          "Update them if you renamed project.name in supatype.config.ts.",
+      )
+    }
+  } catch {
+    // ignore invalid package.json
+  }
+}

package/src/config.ts

@@ -9,6 +9,7 @@ import {
   type SupatypeProjectConfig,
 } from "./project-config.js"
 import { extractSchemaAstFromTypes } from "./type-extractor.js"
+import type { ExtractedSchemaAstV2 } from "./schema-ast-v2.js"
 
 export type { SupatypeProjectConfig } from "./project-config.js"
 
@@ -206,7 +207,7 @@ process.stdout.write(JSON.stringify(config))
 export function loadSchemaAst(
   schemaPath: string,
   cwd: string = process.cwd(),
-): unknown {
+): ExtractedSchemaAstV2 {
   const extracted = extractSchemaAstFromTypes(schemaPath, cwd)
   if (extracted !== null) return extracted