@supatype/cli 0.1.0-alpha.8 → 0.1.0

package/src/pull-utils.ts

@@ -1,41 +1,237 @@
 /**
- * Utilities for the `pull` command — extracted for unit testability.
+ * Utilities for `pull` and `introspect` — map engine DatabaseState to Model<> scaffold.
  */
 
-export interface ColumnInfo {
+export interface DbColumnState {
   name: string
-  pgType: string
+  dataType: string
+  udtName: string
   nullable: boolean
+  default?: string | null
+  ordinalPosition?: number
+}
+
+export interface DbTableState {
+  schema?: string
+  name: string
+  columns: DbColumnState[]
+}
+
+export interface DbConstraintState {
+  table: string
+  name: string
+  constraintType: string
+  columns: string[]
+  foreignTable?: string | null
+  foreignColumns?: string[] | null
+  comment?: string | null
+}
+
+export interface DbIndexState {
+  table: string
+  name: string
+  columns: string[]
+  unique: boolean
+  method: string
   isPrimary: boolean
-  isUnique: boolean
-  hasDefault: boolean
+  comment?: string | null
 }
 
-/** Engine `/introspect` column shape (see {@link IntrospectResult} in engine-client). */
-export interface IntrospectColumn {
+export interface DatabaseStateJson {
+  schema?: string
+  tables: DbTableState[]
+  constraints?: DbConstraintState[]
+  indexes?: DbIndexState[]
+}
+
+export interface ColumnInfo {
   name: string
-  type: string
+  pgType: string
   nullable: boolean
-  default?: string
-  primaryKey?: boolean
-  unique?: boolean
+  isPrimary: boolean
+  isUnique: boolean
+  hasDefault: boolean
   references?: { table: string; column: string }
 }
 
-/** Map engine introspection JSON to {@link ColumnInfo} for {@link pgTypeToField}. */
-export function introspectColumnToColumnInfo(col: IntrospectColumn): ColumnInfo {
-  const def = col.default
+/** Map engine introspection column to {@link ColumnInfo}. */
+export function introspectColumnToColumnInfo(col: DbColumnState): ColumnInfo {
   return {
     name: col.name,
-    pgType: col.type,
+    pgType: col.udtName || col.dataType,
     nullable: col.nullable,
-    isPrimary: col.primaryKey ?? false,
-    isUnique: col.unique ?? false,
-    hasDefault: def !== undefined && def !== "",
+    isPrimary: col.name === "id" && (col.udtName === "uuid" || col.dataType.includes("uuid")),
+    isUnique: false,
+    hasDefault: col.default != null && col.default !== "",
+  }
+}
+
+function singleColumnUniques(
+  table: string,
+  constraints: DbConstraintState[] | undefined,
+): Map<string, boolean> {
+  const out = new Map<string, boolean>()
+  for (const c of constraints ?? []) {
+    if (c.table !== table || c.constraintType !== "unique" || c.columns.length !== 1) continue
+    out.set(c.columns[0]!, true)
   }
+  return out
 }
 
-/** Map a Postgres column type to the corresponding field.X() call string. */
+function compositeIndexes(
+  table: string,
+  indexes: DbIndexState[] | undefined,
+): Array<{ fields: string[]; unique: boolean }> {
+  const out: Array<{ fields: string[]; unique: boolean }> = []
+  for (const idx of indexes ?? []) {
+    if (idx.table !== table || idx.isPrimary || idx.columns.length < 2) continue
+    out.push({ fields: idx.columns, unique: idx.unique })
+  }
+  return out
+}
+
+/** Map a Postgres column to a Model<> field type string (draft). */
+export function pgTypeToModelField(col: ColumnInfo): string {
+  const name = col.name
+  const type = col.pgType.toLowerCase()
+  const optional = col.nullable ? "Optional<" : ""
+  const optionalClose = col.nullable ? ">" : ""
+
+  if (name === "id" && type.includes("uuid")) {
+    return `id: SupatypeAuthUserId`
+  }
+  if (name.endsWith("_id") && type.includes("uuid")) {
+    const base = name.replace(/_id$/, "")
+    const rel = base.replace(/_([a-z])/g, (_, c: string) => c.toUpperCase())
+    const relName = rel.charAt(0).toUpperCase() + rel.slice(1)
+    return `${name}: UUID\n  // TODO: relation — RelatedTo<"${relName}">`
+  }
+  if (name === "created_at" || name === "updated_at") {
+    return `${name}: Timestamp`
+  }
+  if (name === "deleted_at") {
+    return `${name}: Optional<Timestamp>`
+  }
+  if (type.includes("timestamptz") || type.includes("timestamp with time zone")) {
+    return `${name}: ${optional}Timestamp${optionalClose}`
+  }
+  if (type.includes("uuid")) {
+    const inner = col.isUnique ? "Unique<UUID>" : "UUID"
+    return `${name}: ${optional}${inner}${optionalClose}`
+  }
+  if (name.includes("email") && (type.includes("text") || type.includes("varchar"))) {
+    const inner = col.isUnique ? "Unique<Email>" : "Email"
+    return `${name}: ${optional}${inner}${optionalClose}`
+  }
+  if (name === "slug" || name.endsWith("_slug")) {
+    return `${name}: Slug<"title">`
+  }
+  if (type.includes("jsonb")) {
+    return `${name}: ${optional}JSON${optionalClose}`
+  }
+  if (type.includes("bool")) {
+    return `${name}: ${optional}boolean${optionalClose}`
+  }
+  if (type.includes("int8") || type.includes("bigint")) {
+    return `${name}: ${optional}BigInt${optionalClose}`
+  }
+  if (type.includes("int")) {
+    return `${name}: ${optional}Int${optionalClose}`
+  }
+  if (type.includes("text") || type.includes("varchar")) {
+    const inner = col.isUnique ? "Unique<string>" : "string"
+    return `${name}: ${optional}${inner}${optionalClose}`
+  }
+
+  return `${name}: string /* TODO: ${col.pgType} */`
+}
+
+/** Convert snake_case table name to PascalCase model export name. */
+export function toModelName(s: string): string {
+  return s
+    .replace(/_([a-z])/g, (_, c: string) => c.toUpperCase())
+    .replace(/^([a-z])/, (c: string) => c.toUpperCase())
+}
+
+/** Generate draft schema/index.ts content from introspected DatabaseState. */
+export function databaseStateToSchemaScaffold(state: DatabaseStateJson): string {
+  const constraints = state.constraints ?? []
+  const indexes = state.indexes ?? []
+  const skipTables = new Set(["spatial_ref_sys", "schema_migrations"])
+
+  const lines: string[] = [
+    "// DRAFT — generated by `supatype pull`. Review access rules, relations, and indexes before push.",
+    'import type { Model, Public, UUID, Timestamp, Optional, Unique, Email, Slug, SupatypeAuthUserId, JSON, Int, BigInt } from "@supatype/types"',
+    "",
+  ]
+
+  for (const table of state.tables) {
+    if (skipTables.has(table.name) || table.name.startsWith("_")) continue
+
+    const modelName = toModelName(table.name)
+    const uniques = singleColumnUniques(table.name, constraints)
+    const modelIndexes = compositeIndexes(table.name, indexes)
+
+    const fieldLines: string[] = []
+    for (const col of table.columns) {
+      if (col.name === "created_at" || col.name === "updated_at") continue
+      const info = introspectColumnToColumnInfo(col)
+      info.isPrimary = col.name === "id"
+      info.isUnique = uniques.get(col.name) ?? false
+      fieldLines.push(`  ${pgTypeToModelField(info)}`)
+    }
+
+    const hasTimestamps = table.columns.some((c) => c.name === "created_at")
+    if (hasTimestamps) {
+      fieldLines.push("  created_at: Timestamp")
+      fieldLines.push("  updated_at: Timestamp")
+    }
+
+    const indexBlock =
+      modelIndexes.length > 0
+        ? `\n  indexes: [\n${modelIndexes
+            .map(
+              (idx) =>
+                `    { fields: [${idx.fields.map((f) => `"${f}"`).join(", ")}]${idx.unique ? ", unique: true" : ""} },`,
+            )
+            .join("\n")}\n  ],`
+        : ""
+
+    lines.push(`export type ${modelName} = Model<{`)
+    lines.push(fieldLines.join("\n"))
+    lines.push(`}, {`)
+    lines.push(`  access: {`)
+    lines.push(`    read: Public`)
+    lines.push(`    create: Public`)
+    lines.push(`    update: Public`)
+    lines.push(`    delete: Public`)
+    lines.push(`  },${indexBlock}`)
+    lines.push(`}>`)
+    lines.push("")
+  }
+
+  return lines.join("\n")
+}
+
+/** Human-readable introspection summary for `supatype introspect`. */
+export function printIntrospectSummary(state: DatabaseStateJson): void {
+  console.log(`Schema: ${state.schema ?? "public"}`)
+  console.log(`Tables: ${state.tables.length}`)
+  for (const table of state.tables) {
+    console.log(`\n  ${table.name} (${table.columns.length} columns)`)
+    for (const col of table.columns) {
+      const nullMark = col.nullable ? "?" : ""
+      console.log(`    ${col.name}${nullMark}: ${col.udtName || col.dataType}`)
+    }
+  }
+  const constraintCount = state.constraints?.length ?? 0
+  const indexCount = state.indexes?.length ?? 0
+  if (constraintCount + indexCount > 0) {
+    console.log(`\nConstraints: ${constraintCount}, Indexes: ${indexCount}`)
+  }
+}
+
+/** @deprecated Legacy pull helper — use {@link pgTypeToModelField}. */
 export function pgTypeToField(col: ColumnInfo): string {
   const opts: Record<string, unknown> = { required: !col.nullable }
   if (col.isPrimary) opts["primaryKey"] = true
@@ -73,9 +269,7 @@ export function pgTypeToField(col: ColumnInfo): string {
   return `field.text({ ...${optsStr} }) /* TODO: ${col.pgType} */`
 }
 
-/** Convert snake_case table name to PascalCase model export name. */
+/** @deprecated Use {@link toModelName}. */
 export function toCamelCase(s: string): string {
-  return s
-    .replace(/_([a-z])/g, (_, c: string) => c.toUpperCase())
-    .replace(/^([a-z])/, (c: string) => c.toUpperCase())
+  return toModelName(s)
 }

package/src/resolve-target.ts

@@ -0,0 +1,419 @@
+import { existsSync, readFileSync } from "node:fs"
+import { resolve } from "node:path"
+import { loadConfig } from "./config.js"
+import type { DiffResult } from "./engine-client.js"
+import { ensureEngine, engineRequest } from "./engine-client.js"
+import type { SchemaSourcesPayload } from "./schema-sources.js"
+import {
+  connectionString,
+  resolveRuntimeProvider,
+  schemaPathFromProject,
+  serverBaseUrl,
+} from "./project-config.js"
+import {
+  getEnvironmentTarget,
+  loadLocalEnvironment,
+  loadProjectLink,
+  resolveEnvironmentName,
+  resolveEnvironmentToken,
+  type BranchContext,
+  type LocalEnvironment,
+  type ProjectLink,
+} from "./link.js"
+import { targetFetch } from "./target-client.js"
+
+export interface ResolveTargetFlags {
+  env?: string | undefined
+  direct?: boolean
+  local?: boolean
+  connection?: string | undefined
+}
+
+export type TargetMode = "cloud" | "self-host" | "local" | "direct"
+
+export interface DeployTarget {
+  mode: TargetMode
+  environment: string
+  projectRef: string
+  apiBaseUrl: string
+  apiPrefix: "/api/v1" | "/platform/v1"
+  token?: string | undefined
+  orgId?: string | undefined
+  link: ProjectLink | null
+  /** Engine subprocess path when mode is direct or local without control plane. */
+  databaseUrl?: string
+}
+
+export function loadLocalEnvironmentFile(cwd: string): LocalEnvironment | null {
+  return loadLocalEnvironment(cwd)
+}
+
+function readServiceRoleKey(cwd: string): string | undefined {
+  return process.env["SERVICE_ROLE_KEY"] ?? process.env["SUPATYPE_SERVICE_ROLE_KEY"]
+}
+
+function resolveLocalToken(cwd: string): string | undefined {
+  return readServiceRoleKey(cwd)
+}
+
+export function loadBranchContext(cwd: string): BranchContext | null {
+  const path = resolve(cwd, ".supatype/branch.json")
+  if (!existsSync(path)) return null
+  return JSON.parse(readFileSync(path, "utf8")) as BranchContext
+}
+
+function resolveBranchDefaults(cwd: string, configEnvDefault?: string): string | undefined {
+  if (configEnvDefault) return configEnvDefault
+  try {
+    const config = loadConfig(cwd)
+    const branchDefaults = config.environments?.branchDefaults
+    if (!branchDefaults) return undefined
+    const { execSync } = require("node:child_process") as typeof import("node:child_process")
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", { cwd, encoding: "utf8" }).trim()
+    return branchDefaults[branch]
+  } catch {
+    return undefined
+  }
+}
+
+export function resolveTarget(cwd: string, flags: ResolveTargetFlags = {}): DeployTarget {
+  const config = loadConfig(cwd)
+  const projectRef = config.project?.name ?? config.project?.ref ?? "project"
+  const branchCtx = loadBranchContext(cwd)
+
+  if (branchCtx) {
+    return {
+      mode: "self-host",
+      environment: `branch:${branchCtx.branchId}`,
+      projectRef,
+      apiBaseUrl: branchCtx.apiUrl.replace(/\/$/, ""),
+      apiPrefix: "/platform/v1",
+      token: branchCtx.token,
+      link: loadProjectLink(cwd),
+    }
+  }
+
+  if (flags.direct || flags.local) {
+    const localEnv = loadLocalEnvironment(cwd)
+    return {
+      mode: "direct",
+      environment: "local",
+      projectRef,
+      apiBaseUrl: (serverBaseUrl(config) ?? "").replace(/\/$/, ""),
+      apiPrefix: "/platform/v1",
+      link: null,
+      databaseUrl:
+        flags.connection ??
+        localEnv?.databaseUrl ??
+        connectionString(config),
+    }
+  }
+
+  const link = loadProjectLink(cwd)
+  const localEnv = loadLocalEnvironment(cwd)
+
+  if (!link) {
+    if (localEnv && resolveRuntimeProvider(config) === "docker") {
+      return {
+        mode: "local",
+        environment: "local",
+        projectRef: localEnv.projectRef,
+        apiBaseUrl: localEnv.apiUrl.replace(/\/$/, ""),
+        apiPrefix: "/platform/v1",
+        token: resolveLocalToken(cwd),
+        link: null,
+        databaseUrl: localEnv.databaseUrl,
+      }
+    }
+    return {
+      mode: "direct",
+      environment: "local",
+      projectRef,
+      apiBaseUrl: (serverBaseUrl(config) ?? "").replace(/\/$/, ""),
+      apiPrefix: "/platform/v1",
+      link: null,
+      databaseUrl: flags.connection ?? connectionString(config),
+    }
+  }
+
+  const envName = resolveEnvironmentName(
+    link,
+    flags.env ?? resolveBranchDefaults(cwd, config.environments?.default),
+  )
+  const envTarget = getEnvironmentTarget(link, envName)
+  if (!envTarget) {
+    throw new Error(
+      `Environment "${envName}" not linked. Run: supatype link --env ${envName} ... or supatype envs list`,
+    )
+  }
+
+  const token = resolveEnvironmentToken(link, envTarget)
+  if (!token) {
+    throw new Error(`No token for environment "${envName}". Re-run supatype link --token ...`)
+  }
+
+  if (link.kind === "cloud") {
+    return {
+      mode: "cloud",
+      environment: envName,
+      projectRef: link.projectRef,
+      apiBaseUrl: (link.cloudApiUrl ?? envTarget.apiUrl).replace(/\/$/, ""),
+      apiPrefix: "/api/v1",
+      token,
+      link,
+      ...(link.orgId !== undefined ? { orgId: link.orgId } : {}),
+    }
+  }
+
+  return {
+    mode: link.kind === "local" ? "local" : "self-host",
+    environment: envName,
+    projectRef: link.projectRef,
+    apiBaseUrl: envTarget.apiUrl.replace(/\/$/, ""),
+    apiPrefix: "/platform/v1",
+    token,
+    link,
+  }
+}
+
+function projectPath(target: DeployTarget, subpath: string): string {
+  return `/projects/${target.projectRef}${subpath}`
+}
+
+export async function targetSchemaDiff(
+  target: DeployTarget,
+  ast: unknown,
+  opts?: { schema?: string },
+): Promise<DiffResult> {
+  if (target.mode === "direct" || (target.mode === "local" && !target.token)) {
+    await ensureEngine()
+    return engineRequest<DiffResult>("/diff", {
+      ast,
+      database_url: target.databaseUrl!,
+      schema: opts?.schema ?? "public",
+    })
+  }
+
+  return targetFetch<DiffResult>(target.apiBaseUrl, target.apiPrefix, {
+    method: "POST",
+    path: projectPath(target, "/schema/diff"),
+    body: { ast, schema: opts?.schema ?? "public" },
+    token: target.token!,
+    orgId: target.orgId,
+    environment: target.mode === "cloud" ? target.environment : undefined,
+  })
+}
+
+export async function targetSchemaPush(
+  target: DeployTarget,
+  ast: unknown,
+  opts?: { force?: boolean; schema?: string; schemaSources?: SchemaSourcesPayload | null },
+): Promise<{ message?: string; status?: string; name?: string }> {
+  if (target.mode === "direct" || (target.mode === "local" && !target.token)) {
+    await ensureEngine()
+    const body: Record<string, unknown> = {
+      ast,
+      database_url: target.databaseUrl!,
+      schema: opts?.schema ?? "public",
+      force: opts?.force ?? true,
+    }
+    if (opts?.schemaSources) {
+      body["schema_sources_gz_base64"] = opts.schemaSources.dataBase64
+      body["schema_sources_manifest"] = opts.schemaSources.manifest
+    }
+    return engineRequest("/push", body)
+  }
+
+  const pushBody: Record<string, unknown> = {
+    ast,
+    force: opts?.force ?? true,
+    schema: opts?.schema ?? "public",
+  }
+  if (opts?.schemaSources) {
+    pushBody["schemaSources"] = {
+      manifest: opts.schemaSources.manifest,
+      dataBase64: opts.schemaSources.dataBase64,
+    }
+  }
+
+  return targetFetch(target.apiBaseUrl, target.apiPrefix, {
+    method: "POST",
+    path: projectPath(target, "/schema/push"),
+    body: pushBody,
+    token: target.token!,
+    orgId: target.orgId,
+    environment: target.mode === "cloud" ? target.environment : undefined,
+  })
+}
+
+export interface SchemaRollbackResult {
+  status: string
+  name: string
+  message: string
+  restoredMigrationName?: string
+  schemaSourcesManifest?: SchemaSourcesManifestSummary
+  schemaSourcesBase64?: string
+}
+
+export interface SchemaSourcesManifestSummary {
+  entryPoint?: string
+  fileCount?: number
+  compressedBytes?: number
+  pushedBy?: string
+  files?: Array<{ path: string }>
+}
+
+export interface MigrationListEntry {
+  id: number
+  name: string
+  hash: string
+  appliedAt: string
+  rolledBack: boolean
+  engineVersion: string
+  status: string
+  schemaSourcesManifest?: SchemaSourcesManifestSummary | null
+}
+
+export async function targetSchemaRollback(
+  target: DeployTarget,
+  opts?: { schema?: string },
+): Promise<SchemaRollbackResult> {
+  if (target.mode === "direct" || (target.mode === "local" && !target.token)) {
+    await ensureEngine()
+    return engineRequest<SchemaRollbackResult>("/rollback", {
+      database_url: target.databaseUrl!,
+      schema: opts?.schema ?? "public",
+    })
+  }
+
+  return targetFetch<SchemaRollbackResult>(target.apiBaseUrl, target.apiPrefix, {
+    method: "POST",
+    path: projectPath(target, "/schema/rollback"),
+    body: { schema: opts?.schema ?? "public" },
+    token: target.token!,
+    orgId: target.orgId,
+    environment: target.mode === "cloud" ? target.environment : undefined,
+  })
+}
+
+export async function targetListMigrations(
+  target: DeployTarget,
+): Promise<MigrationListEntry[]> {
+  if (target.mode === "direct" || (target.mode === "local" && !target.token)) {
+    await ensureEngine()
+    const result = await engineRequest<{ migrations?: MigrationListEntry[] } | MigrationListEntry[]>(
+      "/migrations",
+      { database_url: target.databaseUrl!, action: "list" },
+    )
+    return Array.isArray(result) ? result : (result.migrations ?? [])
+  }
+
+  return targetFetch<MigrationListEntry[]>(target.apiBaseUrl, target.apiPrefix, {
+    method: "GET",
+    path: projectPath(target, "/schema/migrations"),
+    token: target.token!,
+    orgId: target.orgId,
+    environment: target.mode === "cloud" ? target.environment : undefined,
+  })
+}
+
+export async function targetSchemaDoctor(
+  target: DeployTarget,
+  ast: unknown,
+  opts?: { noCache?: boolean | undefined; schema?: string },
+): Promise<unknown> {
+  if (target.mode === "direct" || (target.mode === "local" && !target.token)) {
+    await ensureEngine()
+    return engineRequest("/doctor", {
+      ast,
+      database_url: target.databaseUrl!,
+      schema: opts?.schema ?? "public",
+      no_cache: opts?.noCache ?? false,
+    })
+  }
+
+  return targetFetch(target.apiBaseUrl, target.apiPrefix, {
+    method: "POST",
+    path: projectPath(target, "/schema/doctor"),
+    body: { ast, no_cache: opts?.noCache ?? false, schema: opts?.schema ?? "public" },
+    token: target.token!,
+    orgId: target.orgId,
+    environment: target.mode === "cloud" ? target.environment : undefined,
+  })
+}
+
+export async function targetSchemaIntrospect(
+  target: DeployTarget,
+  opts?: { schema?: string },
+): Promise<unknown> {
+  if (target.mode === "direct" || (target.mode === "local" && !target.token)) {
+    await ensureEngine()
+    return engineRequest("/introspect", {
+      database_url: target.databaseUrl!,
+      schema: opts?.schema ?? "public",
+    })
+  }
+
+  return targetFetch(target.apiBaseUrl, target.apiPrefix, {
+    method: "POST",
+    path: projectPath(target, "/schema/introspect"),
+    body: { schema: opts?.schema ?? "public" },
+    token: target.token!,
+    orgId: target.orgId,
+    environment: target.mode === "cloud" ? target.environment : undefined,
+  })
+}
+
+export async function targetSchemaAdopt(
+  target: DeployTarget,
+  ast: unknown,
+  opts?: { names?: string[]; schema?: string; yes?: boolean; noCache?: boolean },
+): Promise<unknown> {
+  if (target.mode === "direct" || (target.mode === "local" && !target.token)) {
+    await ensureEngine()
+    return engineRequest("/adopt", {
+      ast,
+      database_url: target.databaseUrl!,
+      schema: opts?.schema ?? "public",
+      names: opts?.names,
+      yes: opts?.yes ?? false,
+      no_cache: opts?.noCache ?? false,
+    })
+  }
+
+  return targetFetch(target.apiBaseUrl, target.apiPrefix, {
+    method: "POST",
+    path: projectPath(target, "/schema/adopt"),
+    body: {
+      ast,
+      schema: opts?.schema ?? "public",
+      yes: opts?.yes ?? false,
+      no_cache: opts?.noCache ?? false,
+      ...(opts?.names !== undefined ? { names: opts.names } : {}),
+    },
+    token: target.token!,
+    orgId: target.orgId,
+    environment: target.mode === "cloud" ? target.environment : undefined,
+  })
+}
+
+export async function targetStatus(target: DeployTarget): Promise<unknown> {
+  if (target.mode === "direct") {
+    return { mode: "direct", environment: target.environment }
+  }
+
+  return targetFetch(target.apiBaseUrl, target.apiPrefix, {
+    method: "GET",
+    path: projectPath(target, "/status"),
+    token: target.token!,
+    orgId: target.orgId,
+    environment: target.mode === "cloud" ? target.environment : undefined,
+  })
+}
+
+export function schemaPgSchema(cwd: string): string {
+  const config = loadConfig(cwd)
+  return config.schema?.pg_schema ?? "public"
+}
+
+export { schemaPathFromProject }