@supatype/cli 0.1.0-alpha.6 → 0.1.0-alpha.8

package/src/functions-router-gen.ts

@@ -0,0 +1,224 @@
+/**
+ * Generates a Deno router entrypoint so `deno run` (optionally `deno run --watch` in dev)
+ * can serve multiple handlers (same routing contract as `supatype functions serve`).
+ */
+import {
+  basename,
+  join,
+  relative,
+  dirname,
+  resolve as pathResolve,
+} from "node:path"
+import { existsSync, readdirSync, statSync, mkdirSync, writeFileSync } from "node:fs"
+
+export interface DiscoveredFunctionRoute {
+  name: string
+  entrypoint: string
+}
+
+/** Discover *.ts handlers and `{name}/index.ts` dirs; skips `_shared`, dotfiles. */
+export function discoverTsFunctionsInDir(functionsDir: string): DiscoveredFunctionRoute[] {
+  if (!existsSync(functionsDir)) return []
+
+  const entries = readdirSync(functionsDir)
+  const out: DiscoveredFunctionRoute[] = []
+
+  for (const entry of entries) {
+    if (entry.startsWith("_") || entry.startsWith(".")) continue
+
+    const fullPath = join(functionsDir, entry)
+    const st = statSync(fullPath)
+
+    if (st.isDirectory()) {
+      const indexTs = join(fullPath, "index.ts")
+      if (existsSync(indexTs)) out.push({ name: entry, entrypoint: indexTs })
+    } else if (entry.endsWith(".ts") && !entry.endsWith(".d.ts")) {
+      const name = basename(entry, ".ts")
+      out.push({ name, entrypoint: fullPath })
+    }
+  }
+
+  return out.sort((a, b) => a.name.localeCompare(b.name))
+}
+
+function importSpecFromRouter(routerFilePath: string, entrypoint: string): string {
+  const rel = relative(dirname(routerFilePath), entrypoint).replace(/\\/g, "/")
+  if (!rel.startsWith(".")) return `./${rel}`
+  return rel
+}
+
+/** Router source rooted at routerFilePath (defines import paths). */
+export function generateFunctionsRouterSource(
+  routerFilePath: string,
+  fns: DiscoveredFunctionRoute[],
+): string {
+  const imports = fns.map(
+    (fn, i) =>
+      `import handler_${i} from "${importSpecFromRouter(routerFilePath, fn.entrypoint)}"`,
+  )
+  const routes = fns.map((fn, i) => `  "${fn.name}": handler_${i},`)
+
+  return `// Auto-generated — do not edit (regenerated by supatype dev / functions serve)
+${imports.join("\n")}
+
+const handlers: Record<string, (req: Request) => Response | Promise<Response>> = {
+${routes.join("\n")}
+}
+
+const port = parseInt(Deno.env.get("PORT") ?? "8001", 10)
+const functionsDir = Deno.env.get("SUPATYPE_DENO_FUNCTIONS_DIR") ?? ""
+const normalizedFunctionsDir = functionsDir.endsWith("/") ? functionsDir.slice(0, -1) : functionsDir
+const sharedEnvPath = Deno.env.get("SUPATYPE_SHARED_ENV_FILE")
+  ?? (normalizedFunctionsDir ? normalizedFunctionsDir + "/.env.local" : "")
+
+let envLock: Promise<void> = Promise.resolve()
+
+async function withEnvLock<T>(run: () => Promise<T>): Promise<T> {
+  const prev = envLock
+  let release: () => void = () => {}
+  envLock = new Promise<void>(resolve => { release = resolve })
+  await prev
+  try {
+    return await run()
+  } finally {
+    release()
+  }
+}
+
+async function readEnvFile(path: string): Promise<Record<string, string>> {
+  if (!path) return {}
+  try {
+    const text = await Deno.readTextFile(path)
+    const out: Record<string, string> = {}
+    for (const line of text.split("\\n")) {
+      const trimmed = line.trim()
+      if (!trimmed || trimmed.startsWith("#")) continue
+      const eq = trimmed.indexOf("=")
+      if (eq <= 0) continue
+      out[trimmed.slice(0, eq)] = trimmed.slice(eq + 1)
+    }
+    return out
+  } catch {
+    return {}
+  }
+}
+
+async function scopedEnvForFunction(fnName: string): Promise<Record<string, string>> {
+  const shared = await readEnvFile(sharedEnvPath)
+  if (!normalizedFunctionsDir) return shared
+  const fnPath = normalizedFunctionsDir + "/.env." + fnName + ".local"
+  const fnVars = await readEnvFile(fnPath)
+  return { ...shared, ...fnVars }
+}
+
+async function runWithScopedEnv<T>(fnName: string, run: () => Promise<T>): Promise<T> {
+  return withEnvLock(async () => {
+    const scoped = await scopedEnvForFunction(fnName)
+    const prev = new Map<string, string | undefined>()
+    for (const [k, v] of Object.entries(scoped)) {
+      prev.set(k, Deno.env.get(k))
+      Deno.env.set(k, v)
+    }
+    try {
+      return await run()
+    } finally {
+      for (const k of Object.keys(scoped)) {
+        const old = prev.get(k)
+        if (old === undefined) Deno.env.delete(k)
+        else Deno.env.set(k, old)
+      }
+    }
+  })
+}
+
+Deno.serve({ port }, async (req: Request): Promise<Response> => {
+  const url = new URL(req.url)
+  const pathParts = url.pathname
+    .replace(/^\\/functions\\/v1\\/?/, "")
+    .split("/")
+    .filter(Boolean)
+  const fnName = pathParts[0] ?? ""
+
+  if (!fnName || !handlers[fnName]) {
+    return new Response(JSON.stringify({
+      error: "not_found",
+      message: fnName ? \`Function "\${fnName}" not found\` : "No function specified",
+      available: Object.keys(handlers),
+    }), { status: 404, headers: { "Content-Type": "application/json" } })
+  }
+
+  try {
+    const start = performance.now()
+    const response = await runWithScopedEnv(fnName, async () => {
+      const prev = new Map<string, string | undefined>()
+      const setScoped = (key: string, value: string | undefined) => {
+        if (value === undefined || value.length === 0) return
+        prev.set(key, Deno.env.get(key))
+        Deno.env.set(key, value)
+      }
+
+      // Supatype runtime defaults available to every invocation.
+      const supatypeUrl = Deno.env.get("SUPATYPE_URL")
+      const supatypeAnon = Deno.env.get("SUPATYPE_ANON_KEY")
+      const supatypeServiceRole = Deno.env.get("SUPATYPE_SERVICE_ROLE_KEY")
+      const supatypeDbUrl = Deno.env.get("SUPATYPE_DB_URL") ?? Deno.env.get("DATABASE_URL")
+      const supatypeJwks = Deno.env.get("SUPATYPE_JWKS")
+
+      setScoped("SUPATYPE_URL", supatypeUrl)
+      setScoped("SUPATYPE_ANON_KEY", supatypeAnon)
+      setScoped("SUPATYPE_SERVICE_ROLE_KEY", supatypeServiceRole)
+      setScoped("SUPATYPE_DB_URL", supatypeDbUrl)
+      setScoped("SUPATYPE_JWKS", supatypeJwks)
+      if (!Deno.env.get("SUPATYPE_PUBLISHABLE_KEYS") && supatypeAnon) {
+        setScoped("SUPATYPE_PUBLISHABLE_KEYS", JSON.stringify({ anon: supatypeAnon }))
+      }
+      if (!Deno.env.get("SUPATYPE_SECRET_KEYS") && supatypeServiceRole) {
+        setScoped("SUPATYPE_SECRET_KEYS", JSON.stringify({ service_role: supatypeServiceRole }))
+      }
+
+      setScoped("SUPATYPE_REGION", Deno.env.get("SUPATYPE_REGION") ?? "local")
+      setScoped("SUPATYPE_EXECUTION_ID", crypto.randomUUID())
+      setScoped("DENO_DEPLOYMENT_ID", Deno.env.get("DENO_DEPLOYMENT_ID") ?? "local-dev")
+
+      try {
+        return await handlers[fnName]!(req)
+      } finally {
+        for (const [key, old] of prev.entries()) {
+          if (old === undefined) Deno.env.delete(key)
+          else Deno.env.set(key, old)
+        }
+      }
+    })
+    const duration = (performance.now() - start).toFixed(1)
+    console.log(\`\${req.method} /functions/v1/\${fnName} → \${response.status} (\${duration}ms)\`)
+    return response
+  } catch (err) {
+    console.error(\`Error in function "\${fnName}":\`, err)
+    return new Response(JSON.stringify({
+      error: "function_error",
+      message: err instanceof Error ? err.message : "Unknown error",
+    }), { status: 500, headers: { "Content-Type": "application/json" } })
+  }
+})
+`
+}
+
+/**
+ * Writes `.supatype/functions-router.ts` under project cwd. Returns absolute path or null if no handlers.
+ * Pass `routes` when callers already scanned the dir to avoid duplicate I/O.
+ */
+export function writeDevFunctionsRouter(
+  cwd: string,
+  functionsDir: string,
+  routes?: DiscoveredFunctionRoute[],
+): string | null {
+  const fns = routes ?? discoverTsFunctionsInDir(functionsDir)
+  if (fns.length === 0) return null
+
+  const supatypeDir = pathResolve(cwd, ".supatype")
+  mkdirSync(supatypeDir, { recursive: true })
+  const routerPath = join(supatypeDir, "functions-router.ts")
+  const src = generateFunctionsRouterSource(routerPath, fns)
+  writeFileSync(routerPath, src, "utf8")
+  return routerPath
+}

package/src/index.ts

@@ -4,16 +4,8 @@
  * For CLI usage: use the `supatype` binary.
  */
 
-export { invokeEngine, getEnginePath, ensureEngine, getEnginePathAsync } from "./engine.js"
-export {
-  ENGINE_VERSION,
-  ENGINE_REPO,
-  ENGINE_DOWNLOAD_BASE,
-  CDN_BASE_URL,
-  ENGINE_RELEASES_REPO,
-  GITHUB_RELEASES_FALLBACK_URL,
-} from "./engine-version.js"
+export { ensureEngine, engineRequest, engineHealth, EngineError } from "./engine-client.js"
+export type { EngineResult, DiffResult, Operation, IntrospectResult } from "./engine-client.js"
 export { defineConfig, loadConfig, loadSchemaAst } from "./config.js"
-export type { SupatypeConfig } from "./config.js"
-export { detectPlatform } from "./engine/platform.js"
-export type { PlatformInfo } from "./engine/platform.js"
+export type { SupatypeConfig, SupatypeProjectConfig } from "./config.js"
+export { schemaPathFromProject, localDSN, connectionString, serverBaseUrl } from "./project-config.js"

package/src/kong-config.ts

@@ -0,0 +1,93 @@
+/**
+ * Kong declarative config for local dev and self-hosted production.
+ * When `engineGatewayKey` is set, `/studio-config` and `/sql` require `apikey` (key-auth).
+ */
+
+export interface KongDeclarativeOptions {
+  /**
+   * When non-empty, Kong `key-auth` is enabled on engine routes; clients must send
+   * header `apikey: <key>` (same convention as PostgREST). Omit for open local dev.
+   */
+  engineGatewayKey?: string | undefined
+  appUpstream?: string | undefined
+  staticAppServiceUrl?: string | undefined
+  functionsServiceUrl?: string | undefined
+  /** Self-host: route API paths through supatype-server (see runtime-routes). */
+  unifiedGateway?: boolean | undefined
+  /** Studio UI upstream (default: in-compose `studio:3002`). */
+  studioServiceUrl?: string | undefined
+  /** See {@link RuntimeRouteOptions.studioStripPath}. */
+  studioStripPath?: boolean | undefined
+}
+
+/** Escape a string for use inside YAML double quotes. */
+function yamlQuotedString(s: string): string {
+  return JSON.stringify(s)
+}
+
+import { runtimeRouteSpec } from "./runtime-routes.js"
+
+/**
+ * Build full `kong.yml` content. Single source of truth for CLI `dev` and `self-host setup`.
+ */
+export function buildKongDeclarative(opts: KongDeclarativeOptions = {}): string {
+  const gatewayKey = opts.engineGatewayKey?.trim()
+  const secured = Boolean(gatewayKey)
+  const routes = runtimeRouteSpec({
+    ...(opts.unifiedGateway === true && { unifiedGateway: true }),
+    ...(opts.unifiedGateway !== true && opts.appUpstream !== undefined && { appUpstream: opts.appUpstream }),
+    ...(opts.unifiedGateway !== true &&
+      opts.staticAppServiceUrl !== undefined && { staticAppServiceUrl: opts.staticAppServiceUrl }),
+    ...(opts.functionsServiceUrl !== undefined && { functionsServiceUrl: opts.functionsServiceUrl }),
+    ...(opts.studioServiceUrl !== undefined && { studioServiceUrl: opts.studioServiceUrl }),
+    ...(opts.studioStripPath === false && { studioStripPath: false }),
+  })
+
+  const consumersBlock = secured
+    ? `
+consumers:
+  - username: studio-engine-gateway
+    keyauth_credentials:
+      - key: ${yamlQuotedString(gatewayKey!)}
+`
+    : ""
+
+  const servicesBlock = routes.map((route) => {
+    const routePlugins = route.engineProtected && secured
+      ? `        plugins:
+          - name: key-auth
+            config:
+              key_names:
+                - apikey
+              hide_credentials: true
+`
+      : ""
+    const protocols = route.protocols && route.protocols.length > 0
+      ? `        protocols:\n${route.protocols.map((p) => `          - ${p}`).join("\n")}\n`
+      : ""
+    const stripPath = route.stripPath ?? false
+    const graphqlPlugins = route.graphqlPostgrest
+      ? `        plugins:
+          - name: request-transformer
+            config:
+              add:
+                headers:
+                  - Content-Profile:graphql_public
+`
+      : ""
+    return `  - name: ${route.serviceName}
+    url: ${route.serviceUrl}
+    routes:
+      - name: ${route.name}
+        strip_path: ${stripPath}
+        paths:
+${route.paths.map((path) => `          - ${path}`).join("\n")}
+${protocols}${routePlugins}${graphqlPlugins}`
+  }).join("\n")
+
+  return `_format_version: "3.0"
+${consumersBlock}
+services:
+${servicesBlock}
+`
+}

package/src/local-gateway.ts

@@ -0,0 +1,9 @@
+/**
+ * Host port published for Kong in local Docker Compose. Kong still listens on
+ * 8000 inside the container; this avoids clashing with other tools on :8000.
+ */
+export const LOCAL_KONG_HOST_PORT = 18473
+
+export function localKongBaseUrl(): string {
+  return `http://localhost:${LOCAL_KONG_HOST_PORT}`
+}

package/src/local-storage.ts

@@ -0,0 +1,14 @@
+import { join } from "node:path"
+
+/**
+ * Returns env vars that configure supatype-server to use local-disk storage.
+ * Spread into the server process env when config.storage?.provider !== "s3".
+ *
+ * @param stateDir  Per-project state directory (e.g. ~/.supatype/projects/{name}/)
+ */
+export function localStorageEnv(stateDir: string): Record<string, string> {
+  return {
+    STORAGE_PROVIDER: "local",
+    STORAGE_PATH: join(stateDir, "storage"),
+  }
+}

package/src/pgbouncer-userlist.ts

@@ -0,0 +1,15 @@
+import { createHash } from "node:crypto"
+
+/** PgBouncer md5 auth: "md5" + md5(password + username) — same as supatype-cloud / self-host. */
+export function pgbouncerMd5Hash(password: string, username: string): string {
+  return "md5" + createHash("md5").update(password + username).digest("hex")
+}
+
+/** Two roles used by local compose: superuser pools (GoTrue, engine) and PostgREST. */
+export function pgbouncerUserlistContent(pgPassword: string): string {
+  return `# PgBouncer md5 userlist — matches supatype-cloud transaction pool (auth_type = md5).
+# Regenerated by supatype dev --local / init from POSTGRES_PASSWORD.
+"supatype_admin" "${pgbouncerMd5Hash(pgPassword, "supatype_admin")}"
+"authenticator" "${pgbouncerMd5Hash(pgPassword, "authenticator")}"
+`
+}

package/src/postgres-ctl.ts

@@ -0,0 +1,171 @@
+/**
+ * postgres-ctl — wrappers around pg_ctl, initdb, and pg_isready for managing
+ * a native Postgres installation.
+ */
+
+import { spawnSync } from "node:child_process"
+import { existsSync, mkdirSync } from "node:fs"
+import { dirname, join } from "node:path"
+
+export interface PgOptions {
+  /** Absolute path to the directory containing pg_ctl, initdb, psql, etc. */
+  pgBinDir: string
+  /** Absolute path to the Postgres data directory (PGDATA). */
+  dataDir: string
+  /** Port Postgres should listen on. */
+  port: number
+  /** Path to write the postgres log file. */
+  logPath?: string
+}
+
+/**
+ * Native Postgres bundles are built with prefix /usr/local/supatype-pg; dyld/ld
+ * must load libpq and friends from the extracted lib/ next to bin/.
+ */
+export function pgSpawnEnv(
+  pgBinDir: string,
+  platform: NodeJS.Platform = process.platform,
+): NodeJS.ProcessEnv {
+  const libDir = join(dirname(pgBinDir), "lib")
+  const env = { ...process.env } as NodeJS.ProcessEnv
+  if (platform === "darwin") {
+    const prev = env.DYLD_LIBRARY_PATH ?? ""
+    env.DYLD_LIBRARY_PATH = prev ? `${libDir}:${prev}` : libDir
+  } else if (platform === "linux") {
+    const prev = env.LD_LIBRARY_PATH ?? ""
+    env.LD_LIBRARY_PATH = prev ? `${libDir}:${prev}` : libDir
+  }
+  return env
+}
+
+// ---------------------------------------------------------------------------
+// initdb
+// ---------------------------------------------------------------------------
+
+/**
+ * Initialise a Postgres data directory.
+ * Does nothing if the data directory already contains a PG_VERSION file.
+ */
+export function initdb(opts: PgOptions): void {
+  const pgVersionFile = join(opts.dataDir, "PG_VERSION")
+  if (existsSync(pgVersionFile)) return // Already initialised.
+
+  mkdirSync(opts.dataDir, { recursive: true })
+
+  const bin = pgBin(opts.pgBinDir, "initdb")
+  const result = spawnSync(bin, ["-D", opts.dataDir, "--username", "postgres", "--auth", "trust"], {
+    stdio: "inherit",
+    encoding: "utf8",
+    env: pgSpawnEnv(opts.pgBinDir),
+  })
+
+  if (result.status !== 0) {
+    throw new Error(`initdb failed (exit ${result.status})`)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// start / stop
+// ---------------------------------------------------------------------------
+
+/**
+ * Start Postgres using pg_ctl.
+ * Returns immediately once pg_ctl has handed off to the server process.
+ */
+export function start(opts: PgOptions): void {
+  const bin = pgBin(opts.pgBinDir, "pg_ctl")
+  const logPath = opts.logPath ?? join(opts.dataDir, "postgres.log")
+
+  const args = [
+    "start",
+    "-D", opts.dataDir,
+    "-l", logPath,
+    "-o", `-p ${opts.port}`,
+    "--wait",
+  ]
+
+  const result = spawnSync(bin, args, {
+    stdio: "inherit",
+    encoding: "utf8",
+    env: pgSpawnEnv(opts.pgBinDir),
+  })
+  if (result.status !== 0) {
+    throw new Error(`pg_ctl start failed (exit ${result.status})`)
+  }
+}
+
+/**
+ * Stop Postgres using pg_ctl (fast mode).
+ */
+export function stop(opts: PgOptions): void {
+  const bin = pgBin(opts.pgBinDir, "pg_ctl")
+  const result = spawnSync(bin, ["stop", "-D", opts.dataDir, "-m", "fast", "--wait"], {
+    stdio: "inherit",
+    encoding: "utf8",
+    env: pgSpawnEnv(opts.pgBinDir),
+  })
+  // Ignore exit code — Postgres may already be stopped.
+  void result
+}
+
+// ---------------------------------------------------------------------------
+// waitReady
+// ---------------------------------------------------------------------------
+
+/**
+ * Wait until Postgres is accepting connections.
+ * Polls pg_isready every 200ms up to timeoutMs.
+ * Throws if the timeout is exceeded.
+ */
+export async function waitReady(opts: PgOptions, timeoutMs = 10_000): Promise<void> {
+  const bin = pgBin(opts.pgBinDir, "pg_isready")
+  const deadline = Date.now() + timeoutMs
+
+  while (Date.now() < deadline) {
+    const result = spawnSync(bin, ["-p", String(opts.port), "-q"], {
+      encoding: "utf8",
+      env: pgSpawnEnv(opts.pgBinDir),
+    })
+    if (result.status === 0) return
+
+    await sleep(200)
+  }
+
+  throw new Error(
+    `Postgres did not become ready within ${timeoutMs}ms on port ${opts.port}`,
+  )
+}
+
+// ---------------------------------------------------------------------------
+// Port check
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns true if a TCP listener is already bound to port on 127.0.0.1.
+ */
+export async function isPortInUse(port: number): Promise<boolean> {
+  const { createServer } = await import("node:net")
+  return new Promise((resolve) => {
+    const server = createServer()
+    server.once("error", (err: NodeJS.ErrnoException) => {
+      resolve(err.code === "EADDRINUSE")
+    })
+    server.once("listening", () => {
+      server.close(() => resolve(false))
+    })
+    server.listen(port, "127.0.0.1")
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+/** Returns the full path to a Postgres binary, appending .exe on Windows. */
+function pgBin(binDir: string, name: string): string {
+  return join(binDir, process.platform === "win32" ? `${name}.exe` : name)
+}