@supatype/cli 0.1.9 → 0.1.11

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/src/type-generation.ts

@@ -0,0 +1,60 @@
+/**
+ * Write a project's generated types to disk.
+ *
+ * `push` used to send `types_path` and `client_path` to the engine and read only `message`,
+ * expecting the engine to write the files. It does not write them, so with `output.types`
+ * configured the generated TypeScript was printed to the terminal and nothing reached disk:
+ * `supatype push` claims to generate types and produced none. `supatype generate` had it right
+ * all along, and this is that logic, shared, so the two cannot disagree again.
+ *
+ * Each path is optional and an absent one is skipped, because the two callers differ on purpose:
+ * `generate` falls back to defaults and always writes, while `push` writes only what the project
+ * asked for and must not start creating files in projects that never configured any.
+ */
+
+import { mkdirSync, writeFileSync } from "node:fs"
+import { dirname, resolve } from "node:path"
+import { generateClientAugmentation } from "./augmentation-generator.js"
+import { ensureEngine, engineRequest } from "./engine-client.js"
+
+export interface GenerateTypesRequest {
+  cwd: string
+  ast: unknown
+  /** Relative path for the database types, from `output.types`. */
+  typesPath?: string | undefined
+  /** Relative path for the client augmentation, from `output.client`. */
+  clientPath?: string | undefined
+}
+
+/** Writes what was asked for and returns one message per file, for the caller to report. */
+export async function writeGeneratedTypes(req: GenerateTypesRequest): Promise<string[]> {
+  const written: string[] = []
+
+  if (req.typesPath !== undefined && req.typesPath !== "") {
+    await ensureEngine()
+    const result = await engineRequest<{ code?: string; message?: string }>(
+      "/generate",
+      { ast: req.ast, lang: "typescript" },
+    )
+    // `code` is the field the engine fills; `message` is the older shape. Reading only `message`
+    // and printing it is how the generated file ended up in the terminal.
+    const code = result.code ?? result.message
+    if (code === undefined) {
+      throw new Error("Engine returned no output for type generation.")
+    }
+    const outPath = resolve(req.cwd, req.typesPath)
+    mkdirSync(dirname(outPath), { recursive: true })
+    writeFileSync(outPath, code, "utf8")
+    written.push(`Types written to ${req.typesPath}`)
+  }
+
+  // Generated locally from the AST, so it needs no engine round trip.
+  if (req.clientPath !== undefined && req.clientPath !== "") {
+    const outPath = resolve(req.cwd, req.clientPath)
+    mkdirSync(dirname(outPath), { recursive: true })
+    writeFileSync(outPath, generateClientAugmentation(req.ast), "utf8")
+    written.push(`Client augmentation written to ${req.clientPath}`)
+  }
+
+  return written
+}

package/tests/app-command.test.ts

@@ -12,10 +12,20 @@ const CLI_BIN = resolve(__dirname, "../bin/supatype.js")
 
 function runCli(cwd: string, args: string[]): { stdout: string; stderr: string; exitCode: number } {
   const result = spawnSync(process.execPath, [CLI_BIN, ...args], {
-    encoding: "utf8",
     cwd,
-    timeout: 10_000,
+    encoding: "utf8",
+    // 60s, not 10s: this spawns the built CLI, which imports Ink, React and commander before it
+    // does anything. That is about 1.2s idle, and CI runs `turbo run test` across every package at
+    // once, where it exceeded 10s and the subprocess was killed. The assertion then compared
+    // against empty output and pointed at the CLI rather than at contention.
+    timeout: 60_000,
   })
+  if (result.signal) {
+    throw new Error(
+      `CLI subprocess killed by ${result.signal} after the spawn timeout. `
+        + `Args: ${args.join(" ")}. This is usually machine contention, not a CLI fault.`,
+    )
+  }
   return {
     stdout: String(result.stdout ?? ""),
     stderr: String(result.stderr ?? ""),

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")
+  })
+})