@supatype/cli 0.1.0-alpha.10 → 0.1.0-alpha.12

package/src/commands/functions.ts

@@ -21,7 +21,9 @@ import {
   discoverTsFunctionsInDir,
   generateFunctionsRouterSource,
 } from "../functions-router-gen.js"
-import { selfHostComposePaths } from "../self-host-compose.js"
+import { loadProjectLink } from "../link.js"
+import { resolveTarget } from "../resolve-target.js"
+import { targetFetch } from "../target-client.js"
 
 // ─── Constants ───────────────────────────────────────────────────────────────
 
@@ -56,8 +58,9 @@ export function registerFunctions(program: Command): void {
     .command("deploy")
     .description("Deploy all functions (or --only <name> for one) to the linked project")
     .option("--only <name>", "Deploy a single function")
+    .option("--env <name>", "Target environment when linked")
     .option("--dry-run", "Show what would be deployed without deploying")
-    .action(async (opts: { only?: string; dryRun?: boolean }) => {
+    .action(async (opts: { only?: string; env?: string; dryRun?: boolean }) => {
       await deploy(process.cwd(), opts)
     })
 
@@ -327,7 +330,7 @@ async function serve(cwd: string, opts: { port: string; envFile: string }): Prom
 
 // ─── Deploy ──────────────────────────────────────────────────────────────────
 
-async function deploy(cwd: string, opts: { only?: string; dryRun?: boolean }): Promise<void> {
+async function deploy(cwd: string, opts: { only?: string; env?: string; dryRun?: boolean }): Promise<void> {
   const allFns = discoverFunctions(cwd)
   const fns = opts.only
     ? allFns.filter(f => f.name === opts.only)
@@ -353,13 +356,27 @@ async function deploy(cwd: string, opts: { only?: string; dryRun?: boolean }): P
     return
   }
 
+  const link = loadProjectLink(cwd)
+  if (link) {
+    try {
+      const target = resolveTarget(cwd, { env: opts.env })
+      if (target.mode !== "direct" && target.token) {
+        await deployViaTarget(cwd, target, fns)
+        return
+      }
+    } catch {
+      /* fall through to compose/local */
+    }
+  }
+
+  const { selfHostComposePaths } = await import("../self-host-compose.js")
   const composePath = selfHostComposePaths(cwd).composePath
   if (existsSync(composePath)) {
     await deploySelfHosted(cwd, fns)
     return
   }
 
-  await deployCloud(cwd, fns)
+  await deployCloud(cwd, fns, opts.env)
 }
 
 async function deploySelfHosted(cwd: string, fns: DiscoveredFunction[]): Promise<void> {
@@ -376,7 +393,49 @@ async function deploySelfHosted(cwd: string, fns: DiscoveredFunction[]): Promise
   console.log("\nKong → supatype-server → functions-worker (per-project worker).")
 }
 
-async function deployCloud(cwd: string, fns: DiscoveredFunction[]): Promise<void> {
+async function deployViaTarget(
+  cwd: string,
+  target: ReturnType<typeof resolveTarget>,
+  fns: DiscoveredFunction[],
+): Promise<void> {
+  console.log(`Deploying to ${target.mode} project: ${target.projectRef} (${target.environment})\n`)
+
+  for (const fn of fns) {
+    const start = Date.now()
+    const source = readFunctionSource(fn)
+
+    try {
+      await targetFetch(
+        target.apiBaseUrl,
+        target.apiPrefix,
+        {
+          method: "POST",
+          path: `/projects/${target.projectRef}/functions/deploy`,
+          body: {
+            functions: [{
+              name: fn.name,
+              source,
+              entrypoint: `${fn.name}/index.ts`,
+            }],
+          },
+          token: target.token!,
+          orgId: target.orgId,
+          environment: target.mode === "cloud" ? target.environment : undefined,
+        },
+      )
+
+      const duration = Date.now() - start
+      console.log(`  ${fn.name} ✓ deployed (${duration}ms)`)
+    } catch (err) {
+      console.error(`  ${fn.name} ✗ ${err instanceof Error ? err.message : "unknown error"}`)
+    }
+  }
+
+  console.log(`\nDeployed ${fns.length} function(s)`)
+  void cwd
+}
+
+async function deployCloud(cwd: string, fns: DiscoveredFunction[], env?: string): Promise<void> {
   const { getLinkedProject, getCloudToken, getCloudApiUrl } = await loadCloudHelpers()
   const linked = getLinkedProject(cwd)
 
@@ -385,13 +444,13 @@ async function deployCloud(cwd: string, fns: DiscoveredFunction[]): Promise<void
     process.exit(1)
   }
 
-  const token = getCloudToken()
+  const token = getCloudToken(cwd)
   if (!token) {
     console.error("Not logged in. Run: npx supatype cloud login")
     process.exit(1)
   }
 
-  const apiUrl = getCloudApiUrl()
+  const apiUrl = getCloudApiUrl(cwd)
   console.log(`Deploying to project: ${linked.ref}\n`)
 
   for (const fn of fns) {
@@ -473,14 +532,14 @@ async function listFunctions(cwd: string): Promise<void> {
     return
   }
 
-  const token = getCloudToken()
+  const token = getCloudToken(cwd)
   if (!token) {
     console.error("Not logged in. Run: npx supatype cloud login")
     process.exit(1)
   }
 
   try {
-    const res = await fetch(`${getCloudApiUrl()}/api/v1/projects/${linked.ref}/functions`, {
+    const res = await fetch(`${getCloudApiUrl(cwd)}/api/v1/projects/${linked.ref}/functions`, {
       headers: {
         Authorization: `Bearer ${token}`,
         "X-Org-Id": linked.orgId ?? "",
@@ -527,14 +586,14 @@ async function deleteFunction(cwd: string, name: string): Promise<void> {
     process.exit(1)
   }
 
-  const token = getCloudToken()
+  const token = getCloudToken(cwd)
   if (!token) {
     console.error("Not logged in. Run: npx supatype cloud login")
     process.exit(1)
   }
 
   try {
-    const res = await fetch(`${getCloudApiUrl()}/api/v1/projects/${linked.ref}/functions/${name}`, {
+    const res = await fetch(`${getCloudApiUrl(cwd)}/api/v1/projects/${linked.ref}/functions/${name}`, {
       method: "DELETE",
       headers: {
         Authorization: `Bearer ${token}`,
@@ -567,7 +626,7 @@ async function functionLogs(cwd: string, name: string, opts: { since: string }):
     process.exit(1)
   }
 
-  const token = getCloudToken()
+  const token = getCloudToken(cwd)
   if (!token) {
     console.error("Not logged in. Run: npx supatype cloud login")
     process.exit(1)
@@ -575,7 +634,7 @@ async function functionLogs(cwd: string, name: string, opts: { since: string }):
 
   try {
     const res = await fetch(
-      `${getCloudApiUrl()}/api/v1/projects/${linked.ref}/functions/${name}/logs?since=${opts.since}`,
+      `${getCloudApiUrl(cwd)}/api/v1/projects/${linked.ref}/functions/${name}/logs?since=${opts.since}`,
       {
         headers: {
           Authorization: `Bearer ${token}`,
@@ -625,7 +684,7 @@ async function invoke(
     const linked = getLinkedProject(cwd)
     if (linked) {
       url = `https://${linked.ref}.supatype.dev/functions/v1/${name}`
-      const token = getCloudToken()
+      const token = getCloudToken(cwd)
       if (token && opts.auth) {
         headers["Authorization"] = `Bearer ${token}`
       }
@@ -710,14 +769,14 @@ async function envList(cwd: string): Promise<void> {
     return
   }
 
-  const token = getCloudToken()
+  const token = getCloudToken(cwd)
   if (!token) {
     console.error("Not logged in. Run: npx supatype cloud login")
     process.exit(1)
   }
 
   try {
-    const res = await fetch(`${getCloudApiUrl()}/api/v1/projects/${linked.ref}/functions/env`, {
+    const res = await fetch(`${getCloudApiUrl(cwd)}/api/v1/projects/${linked.ref}/functions/env`, {
       headers: {
         Authorization: `Bearer ${token}`,
         "X-Org-Id": linked.orgId ?? "",
@@ -778,14 +837,14 @@ async function envSet(cwd: string, keyvalue: string): Promise<void> {
     return
   }
 
-  const token = getCloudToken()
+  const token = getCloudToken(cwd)
   if (!token) {
     console.error("Not logged in. Run: npx supatype cloud login")
     process.exit(1)
   }
 
   try {
-    const res = await fetch(`${getCloudApiUrl()}/api/v1/projects/${linked.ref}/functions/env`, {
+    const res = await fetch(`${getCloudApiUrl(cwd)}/api/v1/projects/${linked.ref}/functions/env`, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${token}`,
@@ -828,14 +887,14 @@ async function envUnset(cwd: string, key: string): Promise<void> {
     return
   }
 
-  const token = getCloudToken()
+  const token = getCloudToken(cwd)
   if (!token) {
     console.error("Not logged in. Run: npx supatype cloud login")
     process.exit(1)
   }
 
   try {
-    const res = await fetch(`${getCloudApiUrl()}/api/v1/projects/${linked.ref}/functions/env/${key}`, {
+    const res = await fetch(`${getCloudApiUrl(cwd)}/api/v1/projects/${linked.ref}/functions/env/${key}`, {
       method: "DELETE",
       headers: {
         Authorization: `Bearer ${token}`,
@@ -860,32 +919,29 @@ async function envUnset(cwd: string, key: string): Promise<void> {
 // ─── Cloud helpers (lazy loaded) ─────────────────────────────────────────────
 
 interface CloudHelpers {
-  getLinkedProject(cwd: string): { ref: string; orgId?: string } | null
-  getCloudToken(): string | null
-  getCloudApiUrl(): string
+  getLinkedProject(cwd: string): { ref: string; orgId?: string | undefined; kind?: string } | null
+  getCloudToken(cwd: string): string | null
+  getCloudApiUrl(cwd: string): string
 }
 
 async function loadCloudHelpers(): Promise<CloudHelpers> {
-  // These helpers read the local .supatype/linked.json and auth token
   return {
-    getLinkedProject(cwd: string): { ref: string; orgId?: string } | null {
-      const linkedPath = resolve(cwd, ".supatype/linked.json")
-      if (!existsSync(linkedPath)) return null
-      try {
-        const data = JSON.parse(readFileSync(linkedPath, "utf8")) as Record<string, string>
-        const ref = data["ref"]
-        const orgId = data["orgId"]
-        return ref ? { ref, ...(orgId !== undefined ? { orgId } : {}) } : null
-      } catch {
-        return null
+  getLinkedProject(cwd: string): { ref: string; orgId?: string | undefined; kind?: string } | null {
+      const link = loadProjectLink(cwd)
+      if (!link?.projectRef) return null
+      return {
+        ref: link.projectRef,
+        kind: link.kind,
+        ...(link.orgId !== undefined ? { orgId: link.orgId } : {}),
       }
     },
 
-    getCloudToken(): string | null {
-      // Check env first, then config file
+    getCloudToken(cwd: string): string | null {
       if (process.env["SUPATYPE_ACCESS_TOKEN"]) {
         return process.env["SUPATYPE_ACCESS_TOKEN"]
       }
+      const link = loadProjectLink(cwd)
+      if (link?.token) return link.token
       const tokenPath = resolve(
         process.env["HOME"] ?? process.env["USERPROFILE"] ?? "~",
         ".supatype/token",
@@ -894,7 +950,9 @@ async function loadCloudHelpers(): Promise<CloudHelpers> {
       return readFileSync(tokenPath, "utf8").trim() || null
     },
 
-    getCloudApiUrl(): string {
+    getCloudApiUrl(cwd: string): string {
+      const link = loadProjectLink(cwd)
+      if (link?.cloudApiUrl) return link.cloudApiUrl
       return process.env["SUPATYPE_API_URL"] ?? "https://api.supatype.com"
     },
   }

package/src/commands/init.ts

@@ -88,7 +88,18 @@ function scaffold(dir: string, projectName: string, mode: "dev" | "standalone" =
   write("seed.ts", seedTemplate(projectName))
   write("seeds/.gitkeep", "")
   write("public/.gitkeep", "")
-  write(".gitignore", gitignoreTemplate())
+  const gitignorePath = join(dir, ".gitignore")
+  if (existsSync(gitignorePath)) {
+    const merged = mergeGitignoreTemplate(readFileSync(gitignorePath, "utf8"))
+    if (merged !== readFileSync(gitignorePath, "utf8")) {
+      writeFileSync(gitignorePath, merged, "utf8")
+      console.log("  updated  .gitignore (added .supatype/)")
+    } else {
+      console.log("  skipped  .gitignore (already exists)")
+    }
+  } else {
+    write(".gitignore", gitignoreTemplate())
+  }
 }
 
 // ─── Templates ───────────────────────────────────────────────────────────────
@@ -241,13 +252,23 @@ function gitignoreTemplate(): string {
   return `.env
 node_modules/
 dist/
-.supatype/engine/
-# Local overrides — never commit
+.supatype/
 supatype.local.config.ts
 supatype.local.config.js
 supatype.local.config.mjs
-# Generated by supatype push
+# Generated by supatype push (legacy paths — prefer output.types in config)
 src/types/supatype.d.ts
 src/lib/supatype.ts
 `
 }
+
+export function mergeGitignoreTemplate(existingContent: string): string {
+  if (existingContent.includes(".supatype/") || existingContent.includes(".supatype\n")) {
+    return existingContent
+  }
+  const block = `
+# Supatype — local runtime (contains secrets in link.json)
+.supatype/
+`
+  return existingContent.endsWith("\n") ? `${existingContent}${block}` : `${existingContent}\n${block}`
+}

package/src/commands/introspect.ts

@@ -0,0 +1,47 @@
+import type { Command } from "commander"
+import { writeFileSync } from "node:fs"
+import { loadProjectLink } from "../link.js"
+import { resolveTarget, targetSchemaIntrospect, schemaPgSchema } from "../resolve-target.js"
+import type { DatabaseStateJson } from "../pull-utils.js"
+import { printIntrospectSummary } from "../pull-utils.js"
+
+export function registerIntrospect(program: Command): void {
+  program
+    .command("introspect")
+    .description("Introspect the live Postgres database (JSON or summary)")
+    .option("--connection <url>", "Database connection URL (overrides config)")
+    .option("--env <name>", "Target environment when linked")
+    .option("--direct", "Use local engine subprocess")
+    .option("--json", "Output full DatabaseState JSON")
+    .option("--out <path>", "Write JSON output to a file")
+    .action(async (opts: {
+      connection?: string
+      env?: string
+      direct?: boolean
+      json?: boolean
+      out?: string
+    }) => {
+      const cwd = process.cwd()
+      const pgSchema = schemaPgSchema(cwd)
+
+      const linked = loadProjectLink(cwd)
+      const target = linked && !opts.direct && !opts.connection
+        ? resolveTarget(cwd, { env: opts.env })
+        : resolveTarget(cwd, { env: opts.env, direct: true, connection: opts.connection })
+
+      const state = (await targetSchemaIntrospect(target, { schema: pgSchema })) as DatabaseStateJson
+
+      if (opts.out) {
+        writeFileSync(opts.out, JSON.stringify(state, null, 2), "utf8")
+        console.log(`Wrote introspection to ${opts.out}`)
+        return
+      }
+
+      if (opts.json) {
+        console.log(JSON.stringify(state, null, 2))
+        return
+      }
+
+      printIntrospectSummary(state)
+    })
+}

package/src/commands/link-helpers.ts

@@ -0,0 +1,228 @@
+import type { Command } from "commander"
+import { loadConfig } from "../config.js"
+import {
+  createCloudLink,
+  createSelfHostLink,
+  loadProjectLink,
+  saveProjectLink,
+  type ProjectLink,
+} from "../link.js"
+import { ensureSupatypeGitignore, warnIfLinkNotGitignored } from "../gitignore.js"
+import { targetFetch } from "../target-client.js"
+
+function resolveLinkToken(opts: {
+  token?: string
+  serviceRoleKey?: string
+}): string | undefined {
+  return (
+    opts.token ??
+    opts.serviceRoleKey ??
+    process.env["SUPATYPE_ACCESS_TOKEN"] ??
+    process.env["SUPATYPE_TOKEN"] ??
+    process.env["SERVICE_ROLE_KEY"]
+  )
+}
+
+async function probeSelfHostLink(apiUrl: string, projectRef: string, token: string): Promise<void> {
+  await targetFetch(apiUrl, "/platform/v1", {
+    method: "GET",
+    path: `/projects/${projectRef}/status`,
+    token,
+  })
+}
+
+export function registerEnvs(program: Command): void {
+  const envs = program.command("envs").description("Manage linked deployment environments")
+
+  envs
+    .command("list")
+    .description("List linked environments")
+    .action(() => {
+      const cwd = process.cwd()
+      const link = loadProjectLink(cwd)
+      if (!link) {
+        console.log("Not linked. Run: supatype link")
+        return
+      }
+      console.log(`\nProject: ${link.projectRef} (${link.kind})`)
+      console.log(`Default: ${link.defaultEnvironment}\n`)
+      for (const [name, env] of Object.entries(link.environments)) {
+        const mark = name === link.defaultEnvironment ? " *" : "  "
+        console.log(`${mark} ${name.padEnd(14)} ${env.apiUrl}`)
+      }
+      console.log()
+    })
+
+  envs
+    .command("use <name>")
+    .description("Set the default environment")
+    .action((name: string) => {
+      const cwd = process.cwd()
+      const link = loadProjectLink(cwd)
+      if (!link?.environments[name]) {
+        console.error(`Environment "${name}" is not linked.`)
+        process.exit(1)
+      }
+      link.defaultEnvironment = name
+      saveProjectLink(cwd, link)
+      console.log(`Default environment set to "${name}".`)
+    })
+
+  envs
+    .command("create <name>")
+    .description("Create a cloud environment (staging/preview)")
+    .action(async (name: string) => {
+      const cwd = process.cwd()
+      const link = loadProjectLink(cwd)
+      if (!link || link.kind !== "cloud") {
+        console.error("Cloud link required. Run: supatype link --project <slug>")
+        process.exit(1)
+      }
+      if (!link.token || !link.cloudApiUrl) {
+        console.error("Missing cloud credentials in link.json")
+        process.exit(1)
+      }
+      const bodyName = name === "staging" || name === "preview" ? name : "staging"
+      await targetFetch(link.cloudApiUrl, "/api/v1", {
+        method: "POST",
+        path: `/projects/${link.projectRef}/environments`,
+        body: { name: bodyName },
+        token: link.token,
+        orgId: link.orgId,
+      })
+      const envsList = await targetFetch<Array<{ name: string; apiUrl: string }>>(
+        link.cloudApiUrl,
+        "/api/v1",
+        {
+          method: "GET",
+          path: `/projects/${link.projectRef}/environments`,
+          token: link.token,
+          orgId: link.orgId,
+        },
+      )
+      const updated = createCloudLink({
+        projectRef: link.projectRef,
+        cloudApiUrl: link.cloudApiUrl,
+        token: link.token,
+        environments: envsList.map((e) => ({ name: e.name, apiUrl: e.apiUrl })),
+        existing: link,
+        ...(link.orgId !== undefined ? { orgId: link.orgId } : {}),
+      })
+      saveProjectLink(cwd, updated)
+      console.log(`Environment "${bodyName}" created.`)
+    })
+}
+
+export function registerLinkOptions(linkCmd: Command): void {
+  linkCmd
+    .option("--project <slug>", "Cloud project slug")
+    .option("--url <url>", "Self-host or local Kong URL")
+    .option("--api-url <url>", "Cloud control plane API URL", "https://api.supatype.com")
+    .option("--token <token>", "Access token (cloud PAT or self-host SERVICE_ROLE_KEY)")
+    .option("--service-role-key <key>", "Deprecated alias for --token on self-host")
+    .option("--env <name>", "Environment name (default: production)", "production")
+    .option("--fix-gitignore", "Append .supatype/ to .gitignore if missing")
+}
+
+export async function runLinkAction(opts: {
+  project?: string
+  url?: string
+  apiUrl: string
+  token?: string
+  serviceRoleKey?: string
+  env?: string
+  fixGitignore?: boolean
+}): Promise<void> {
+  const cwd = process.cwd()
+  const config = loadConfig(cwd)
+  const projectRef = config.project?.name ?? "project"
+  const envName = opts.env ?? "production"
+  const token = resolveLinkToken(opts)
+
+  if (opts.fixGitignore) {
+    ensureSupatypeGitignore(cwd)
+  } else {
+    warnIfLinkNotGitignored(cwd)
+  }
+
+  const existing = loadProjectLink(cwd)
+
+  if (opts.url) {
+    if (!token) {
+      console.error("Authentication required. Pass --token $SERVICE_ROLE_KEY")
+      process.exit(1)
+    }
+    const apiUrl = opts.url.replace(/\/$/, "")
+    await probeSelfHostLink(apiUrl, projectRef, token)
+    const link = createSelfHostLink({
+      projectRef,
+      apiUrl,
+      token,
+      envName,
+      existing,
+    })
+    saveProjectLink(cwd, link)
+    console.log(`\nLinked to self-host environment "${envName}" at ${apiUrl}`)
+    console.log(`Config saved to .supatype/link.json\n`)
+    return
+  }
+
+  if (!token) {
+    console.error("Authentication required. Set SUPATYPE_ACCESS_TOKEN or pass --token.")
+    process.exit(1)
+  }
+
+  const cloudApiUrl = opts.apiUrl.replace(/\/$/, "")
+
+  if (opts.project) {
+    const one = await targetFetch<{ slug: string; orgId: string }>(cloudApiUrl, "/api/v1", {
+      method: "GET",
+      path: `/projects/${opts.project}`,
+      token,
+    })
+    let environments: Array<{ name: string; apiUrl: string }> = [
+      { name: "production", apiUrl: cloudApiUrl },
+    ]
+    try {
+      const listed = await targetFetch<Array<{ name: string; apiUrl: string }>>(
+        cloudApiUrl,
+        "/api/v1",
+        {
+          method: "GET",
+          path: `/projects/${opts.project}/environments`,
+          token,
+          orgId: one.orgId,
+        },
+      )
+      if (listed.length > 0) {
+        environments = listed.map((e) => ({ name: e.name, apiUrl: e.apiUrl }))
+      }
+    } catch {
+      // environments optional on older control planes
+    }
+    const link = createCloudLink({
+      projectRef: opts.project,
+      cloudApiUrl,
+      token,
+      orgId: one.orgId,
+      environments,
+      existing,
+    })
+    saveProjectLink(cwd, link)
+    console.log(`\nLinked to cloud project: ${opts.project}`)
+    console.log(`Config saved to .supatype/link.json\n`)
+    return
+  }
+
+  console.error("Specify --project <slug> for cloud or --url <kong-url> for self-host.")
+  process.exit(1)
+}
+
+export function getLinkOrExit(cwd: string): ProjectLink {
+  const link = loadProjectLink(cwd)
+  if (!link) {
+    console.error("Not linked. Run: supatype link")
+    process.exit(1)
+  }
+  return link
+}