@supatype/cli 0.1.9 → 0.1.10

package/src/commands/internal.ts

@@ -3,6 +3,8 @@
  */
 
 import type { Command } from "commander"
+import { resolve } from "node:path"
+import { pathToFileURL } from "node:url"
 import { downloadAll } from "../binary-cache.js"
 import { error, info } from "../ui/messages.js"
 
@@ -20,4 +22,39 @@ export function registerInternalCommands(program: Command): void {
         process.exit(1)
       }
     })
+
+  // Interpreter for the standalone binary. It carries the Bun runtime, so it can import
+  // TypeScript directly; what it cannot do is spawn `node` with `tsx`, because a machine that
+  // installed with `curl | sh` has neither, and neither is embedded. So the binary re-executes
+  // itself for these two jobs rather than reaching for a toolchain that is not there.
+  //
+  // Hidden and prefixed, like _postinstall: they are an implementation detail of config loading,
+  // not commands anyone should run.
+  program
+    .command("_print-module <target>", { hidden: true })
+    .description("Import a module and print its default export as JSON")
+    .action(async (target: string) => {
+      try {
+        const href = target.startsWith("file:") ? target : pathToFileURL(resolve(target)).href
+        const mod = (await import(href)) as { default?: unknown }
+        const value = mod.default ?? mod
+        process.stdout.write(JSON.stringify(value))
+      } catch (err) {
+        // stderr, because the caller parses stdout as JSON and a message there would corrupt it.
+        process.stderr.write(err instanceof Error ? (err.stack ?? err.message) : String(err))
+        process.exit(1)
+      }
+    })
+
+  program
+    .command("_run-ts <file>", { hidden: true })
+    .description("Execute a TypeScript file for its side effects")
+    .action(async (file: string) => {
+      try {
+        await import(pathToFileURL(resolve(file)).href)
+      } catch (err) {
+        process.stderr.write(err instanceof Error ? (err.stack ?? err.message) : String(err))
+        process.exit(1)
+      }
+    })
 }

package/src/config.ts

@@ -2,7 +2,7 @@ import { existsSync, readFileSync, writeFileSync, unlinkSync } from "node:fs"
 import { resolve } from "node:path"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
-import { evalTsSnippet } from "./tsx-runner.js"
+import { importModuleAsJson } from "./tsx-runner.js"
 import { readEnvFile } from "./env-file.js"
 import {
   mergeProjectConfig,
@@ -157,6 +157,37 @@ function configLoadEnv(cwd: string): NodeJS.ProcessEnv {
   return { ...readEnvFile(cwd), ...process.env }
 }
 
+/**
+ * A config file exists but could not be evaluated.
+ *
+ * Distinct from absence on purpose. Six call sites catch config loading so the CLI still works
+ * outside a project, and while they treated both cases the same, a config that failed to load
+ * looked exactly like no config at all. That is how a standalone binary that could not read any
+ * config shipped in v0.1.9 and still appeared to function: `status` printed a stack of stopped
+ * services, and `db check` fell back to DATABASE_URL from .env and reported a connection error.
+ * Those call sites should swallow absence and re-throw this.
+ */
+export class ConfigLoadError extends Error {
+  readonly configPath: string
+
+  constructor(configPath: string, detail: string) {
+    super(`Failed to load ${configPath}:\n${detail}`)
+    this.name = "ConfigLoadError"
+    this.configPath = configPath
+  }
+}
+
+/**
+ * Re-throw a config that exists but could not be read; swallow anything else.
+ *
+ * For the call sites that catch config loading so the CLI still works outside a project. They
+ * want to ignore absence, not breakage, and treating the two alike is what let a standalone
+ * binary that could read no config at all still look like it was working.
+ */
+export function rethrowIfConfigBroken(err: unknown): void {
+  if (err instanceof ConfigLoadError) throw err
+}
+
 function loadFirstTsConfig(
   cwd: string,
   candidates: string[],
@@ -166,24 +197,19 @@ function loadFirstTsConfig(
     if (!existsSync(configPath)) continue
 
     const urlPath = "file:///" + configPath.replace(/\\/g, "/")
-    const snippet = `
-const mod = await import(${JSON.stringify(urlPath)})
-const config = mod.default ?? mod
-process.stdout.write(JSON.stringify(config))
-`
-    const result = evalTsSnippet(snippet, { cwd, env: configLoadEnv(cwd) })
+    const result = importModuleAsJson(urlPath, { cwd, env: configLoadEnv(cwd) })
     if (result.exitCode === 0) {
       return JSON.parse(result.stdout) as Record<string, unknown>
     }
 
     const failure = result.stderr || result.stdout
     if (!shouldStripCliImportOnLoadFailure(failure)) {
-      throw new Error(`Failed to load ${candidate}:\n${failure}`)
+      throw new ConfigLoadError(candidate, failure)
     }
 
     const fallback = loadTsConfigWithoutCliImport(configPath, cwd)
     if (fallback !== null) return fallback
-    throw new Error(`Failed to load ${candidate}:\n${failure}`)
+    throw new ConfigLoadError(candidate, failure)
   }
   return null
 }
@@ -217,12 +243,7 @@ function loadTsConfigWithoutCliImport(
   writeFileSync(tmpPath, wrapper, "utf8")
   try {
     const urlPath = "file:///" + tmpPath.replace(/\\/g, "/")
-    const snippet = `
-const mod = await import(${JSON.stringify(urlPath)})
-const config = mod.default ?? mod
-process.stdout.write(JSON.stringify(config))
-`
-    const result = evalTsSnippet(snippet, { cwd, env: configLoadEnv(cwd) })
+    const result = importModuleAsJson(urlPath, { cwd, env: configLoadEnv(cwd) })
     if (result.exitCode !== 0) return null
     return JSON.parse(result.stdout) as Record<string, unknown>
   } finally {

package/src/resolve-api-url.ts

@@ -2,7 +2,7 @@
  * Resolve the project API base URL (Kong gateway or direct server) for CLI HTTP calls.
  */
 
-import { loadConfig } from "./config.js"
+import { loadConfig, rethrowIfConfigBroken } from "./config.js"
 import { readEnvValue } from "./env-file.js"
 import { serverBaseUrl } from "./project-config.js"
 
@@ -34,7 +34,8 @@ export function resolveProjectApiUrl(cwd: string): string {
     if (fromConfig) {
       return fromConfig.replace(/\/+$/, "")
     }
-  } catch {
+  } catch (err) {
+    rethrowIfConfigBroken(err)
     // No supatype.config: fall through to PORT default.
   }
 

package/src/tsx-runner.ts

@@ -10,6 +10,7 @@ import { createRequire } from "node:module"
 import { fileURLToPath } from "node:url"
 import { writeFileSync, unlinkSync } from "node:fs"
 import { tmpdir } from "node:os"
+import { isCompiledBinary } from "./cli-install-method.js"
 
 const _require = createRequire(import.meta.url)
 
@@ -51,7 +52,9 @@ export function runTsFile(
   filePath: string,
   opts: SpawnSyncOptions = {},
 ): RunResult {
-  const result = spawnSync(process.execPath, [TSX_BIN, filePath], {
+  // Same split as importModuleAsJson: the binary interprets TypeScript itself, Node uses tsx.
+  const argv = isCompiledBinary() ? ["_run-ts", filePath] : [TSX_BIN, filePath]
+  const result = spawnSync(process.execPath, argv, {
     encoding: "utf8",
     maxBuffer: 50 * 1024 * 1024,
     ...opts,
@@ -87,3 +90,39 @@ export function evalTsSnippet(
     }
   }
 }
+
+/**
+ * Import a module and return its default export as JSON text.
+ *
+ * Two interpreters, one contract. Under Node this writes a snippet and runs it through tsx, as
+ * it always has. As a compiled binary it re-executes itself, because there is no node_modules to
+ * resolve tsx from, no writable directory beside the executable, and on a `curl | sh` machine no
+ * Node either: the previous behaviour failed with
+ * `ENOENT: open '/$bunfs/root/supatype-eval-....mts'` and broke init, update, dev and push.
+ *
+ * Callers get the same stdout, stderr and exit code either way.
+ */
+export function importModuleAsJson(
+  target: string,
+  opts: SpawnSyncOptions = {},
+): RunResult {
+  if (isCompiledBinary()) {
+    const result = spawnSync(process.execPath, ["_print-module", target], {
+      encoding: "utf8",
+      maxBuffer: 50 * 1024 * 1024,
+      ...opts,
+    })
+    return {
+      stdout: String(result.stdout ?? ""),
+      stderr: String(result.stderr ?? ""),
+      exitCode: result.status ?? 1,
+    }
+  }
+
+  const snippet = `
+const mod = await import(${JSON.stringify(target)})
+const config = mod.default ?? mod
+process.stdout.write(JSON.stringify(config))
+`
+  return evalTsSnippet(snippet, opts)
+}

package/tests/config-load-failure.test.ts

@@ -0,0 +1,44 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { spawnSync } from "node:child_process"
+import { describe, expect, it } from "vitest"
+
+const CLI = join(import.meta.dirname, "../bin/supatype.js")
+
+function runIn(dir: string, args: string[]): { out: string; code: number } {
+  const r = spawnSync(process.execPath, [CLI, ...args], {
+    cwd: dir,
+    encoding: "utf8",
+    timeout: 60_000,
+  })
+  if (r.signal) throw new Error(`CLI killed by ${r.signal}, usually machine contention`)
+  return { out: `${r.stdout ?? ""}${r.stderr ?? ""}`, code: r.status ?? 1 }
+}
+
+describe("a config that cannot be read", () => {
+  // A broken config used to be indistinguishable from no config: the call sites that catch
+  // loadConfig so the CLI works outside a project swallowed both. That is why a standalone
+  // binary which could read no config at all still looked like it was working, for a whole
+  // release.
+  it("is reported, rather than treated as absent", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-broken-config-"))
+    writeFileSync(
+      join(dir, "supatype.config.ts"),
+      'throw new Error("deliberately broken")\n',
+      "utf8",
+    )
+    const { out, code } = runIn(dir, ["db", "check"])
+    expect(out).toContain("Failed to load supatype.config.ts")
+    expect(out).not.toContain("No connection. Pass --connection")
+    expect(code).not.toBe(0)
+  })
+
+  it("does not stop the CLI working with no config at all", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-no-config-"))
+    mkdirSync(join(dir, "empty"), { recursive: true })
+    const { out } = runIn(join(dir, "empty"), ["db", "check"])
+    expect(out).toContain("No connection. Pass --connection")
+    expect(out).not.toContain("Failed to load")
+  })
+})