@supatype/cli 0.1.0-alpha.10

package/src/commands/generate.ts

@@ -0,0 +1,44 @@
+import type { Command } from "commander"
+import { mkdirSync, writeFileSync } from "node:fs"
+import { resolve, dirname } from "node:path"
+import { loadConfig, loadSchemaAst } from "../config.js"
+import { schemaPathFromProject } from "../project-config.js"
+import { ensureEngine, engineRequest } from "../engine-client.js"
+import { generateClientAugmentation } from "../augmentation-generator.js"
+
+export function registerGenerate(program: Command): void {
+  program
+    .command("generate")
+    .description("Regenerate TypeScript types without running a migration")
+    .option("--connection <url>", "Database connection URL (overrides config)")
+    .action(async (opts: { connection?: string }) => {
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const schemaPath = schemaPathFromProject(config, cwd)
+      const outputTypesPath = config.output?.types ?? "types/database.ts"
+      const outputClientPath = config.output?.client ?? "supatype/generated/index.d.ts"
+
+      await ensureEngine()
+      console.log("Loading schema...")
+      const ast = loadSchemaAst(schemaPath, cwd)
+
+      const result = await engineRequest<{ code?: string; message?: string }>("/generate", { ast, lang: "typescript" })
+
+      const typesCode = result.code ?? result.message
+      if (typesCode === undefined) {
+        console.error("Engine returned no output.")
+        process.exit(1)
+      }
+
+      const outPath = resolve(cwd, outputTypesPath)
+      mkdirSync(dirname(outPath), { recursive: true })
+      writeFileSync(outPath, typesCode, "utf8")
+      console.log(`Types written to ${outputTypesPath}`)
+
+      const augmentationOutPath = resolve(cwd, outputClientPath)
+      const augmentationCode = generateClientAugmentation(ast)
+      mkdirSync(dirname(augmentationOutPath), { recursive: true })
+      writeFileSync(augmentationOutPath, augmentationCode, "utf8")
+      console.log(`Client augmentation written to ${outputClientPath}`)
+    })
+}

package/src/commands/init.ts

@@ -0,0 +1,253 @@
+import type { Command } from "commander"
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { resolve, join, dirname } from "node:path"
+import { fileURLToPath } from "node:url"
+
+export { scaffold }
+
+// ─── Markers used by `supatype app add / remove` (app.ts) ────────────────────
+export const APP_COMPOSE_MARKER = "  # ─── App service (run: supatype app add) ───"
+export const KONG_APP_MARKER = "  # ─── App fallback route (run: supatype app add) ───"
+
+const CLI_PACKAGE_JSON = join(
+  dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "..",
+  "package.json",
+)
+
+function cliPackageVersion(): string {
+  try {
+    const pkg = JSON.parse(readFileSync(CLI_PACKAGE_JSON, "utf8")) as { version?: string }
+    return pkg.version ?? "0.1.0"
+  } catch {
+    return "0.1.0"
+  }
+}
+
+export function registerInit(program: Command): void {
+  program
+    .command("init [name]")
+    .description("Scaffold a new Supatype project")
+    .option(
+      "--mode <mode>",
+      "Server mode in supatype.config.ts: dev (default) | standalone (native ACME — not Compose self-host)",
+      "dev",
+    )
+    .action(async (name?: string, opts: { mode: string } = { mode: "dev" }) => {
+      const projectName = name ?? "my-project"
+      const dir = name ? resolve(process.cwd(), name) : process.cwd()
+
+      if (name && existsSync(dir)) {
+        console.error(`Directory already exists: ${dir}`)
+        process.exit(1)
+      }
+
+      if (name) mkdirSync(dir, { recursive: true })
+
+      scaffold(dir, projectName, opts.mode as "dev" | "standalone")
+
+      console.log(`\nSupatype project ready${name ? ` in ${name}/` : ""}.\n`)
+      console.log("Next steps:")
+      if (name) console.log(`  cd ${name}`)
+      console.log("  npm install")
+      console.log("  supatype keys")
+      console.log("  supatype dev          # Docker Compose stack (Kong :18473)")
+      console.log("  supatype push         # apply schema + generate types")
+      console.log("\nStatic frontend (self-host):")
+      console.log("  supatype app add --static ./public")
+      console.log("  npm run build         # write files into public/")
+      console.log("  supatype self-host compose up -d")
+      if (opts.mode === "standalone") {
+        console.log("\nStandalone (native TLS with ACME):")
+        console.log("  Edit supatype.config.ts — set server.domain")
+        console.log("  supatype dev          # or run supatype-server with your TLS setup")
+      }
+      console.log()
+    })
+}
+
+function scaffold(dir: string, projectName: string, mode: "dev" | "standalone" = "dev"): void {
+  const write = (rel: string, content: string) => {
+    const full = join(dir, rel)
+    mkdirSync(resolve(full, ".."), { recursive: true })
+    writeFileSync(full, content, "utf8")
+    console.log(`  created  ${rel}`)
+  }
+
+  const pkgPath = join(dir, "package.json")
+  if (!existsSync(pkgPath)) {
+    write("package.json", packageJsonTemplate(projectName, cliPackageVersion()))
+  } else {
+    console.log("  skipped  package.json (already exists)")
+  }
+
+  write("supatype.config.ts", tsConfigTemplate(projectName, mode))
+  write("schema/index.ts", schemaTemplate())
+  write(".env", envTemplate(projectName))
+  write("seed.ts", seedTemplate(projectName))
+  write("seeds/.gitkeep", "")
+  write("public/.gitkeep", "")
+  write(".gitignore", gitignoreTemplate())
+}
+
+// ─── Templates ───────────────────────────────────────────────────────────────
+
+function packageJsonTemplate(projectName: string, cliVersion: string): string {
+  return `{
+  "name": "${projectName}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "supatype dev",
+    "push": "supatype push",
+    "seed": "tsx seed.ts"
+  },
+  "dependencies": {
+    "@supatype/cli": "^${cliVersion}",
+    "@supatype/types": "^${cliVersion}"
+  },
+  "devDependencies": {
+    "tsx": "^4.19.2",
+    "typescript": "^5"
+  }
+}
+`
+}
+
+function tsConfigTemplate(projectName: string, mode: "dev" | "standalone"): string {
+  const domainField =
+    mode === "standalone"
+      ? `    domain: "",  // e.g. "api.example.com" for ACME TLS\n`
+      : ""
+  return `import { defineConfig } from "@supatype/cli"
+
+export default defineConfig({
+  project: { name: "${projectName}" },
+  provider: "docker",
+  // provider: "native"  // host Postgres + supatype-server binaries (no Docker)
+  database: {
+    provider: "docker",
+  },
+  server: {
+    mode: "${mode}",
+    port: 54321,
+${domainField}  },
+  app: {
+    mode: "none",
+    // mode: "static", static_dir: "./public",  // supatype app add --static ./public
+    // mode: "proxy", upstream: "http://localhost:3000", start: "dev",
+    // vite_dev_url: "http://127.0.0.1:5173",  // dev HMR at /_vite (when using a separate Vite server)
+  },
+  // Optional: pin component versions (native cache + Docker images synced to .env on dev/push)
+  // versions: { engine: "0.1.2", server: "1.0.5", postgres: "17.2", deno: "2.2.0" },
+  email: { provider: "console" },
+  storage: { provider: "local", local_path: ".supatype/storage" },
+  schema: { path: "schema/index.ts", pg_schema: "public" },
+  // Self-host production: supatype self-host compose (Docker only). Standalone + domain = native ACME dev.
+})
+`
+}
+
+function schemaTemplate(): string {
+  return `import type { Model, Public, Owner, Role, SupatypeAuthUserId, Unique, Email, UUID } from "@supatype/types"
+
+export type User = Model<{
+  id: SupatypeAuthUserId
+  email: Unique<Email>
+  name: string
+  created_at: string
+  updated_at: string
+}, {
+  access: {
+    read: Public
+    create: Public
+    update: Owner<"id">
+    delete: Role<"admin">
+  }
+}>
+
+/** Example singleton global — editable in Studio under Settings. */
+export type SiteSettings = Model<{
+  id: UUID
+  site_name: string
+}, {
+  singleton: true
+  access: {
+    read: Public
+    update: Role<"admin">
+  }
+}>
+`
+}
+
+function envTemplate(projectName: string): string {
+  return `DATABASE_URL=postgresql://supatype_admin:postgres@localhost:5432/${projectName}
+POSTGRES_USER=supatype_admin
+POSTGRES_PASSWORD=postgres
+POSTGRES_DB=${projectName}
+
+# JWT — run \`supatype keys\` to generate ANON_KEY and SERVICE_ROLE_KEY
+JWT_SECRET=super-secret-jwt-token-change-in-production
+ANON_KEY=
+SERVICE_ROLE_KEY=
+
+# Site URL (used by GoTrue for email redirects)
+SITE_URL=http://localhost:3000
+
+# SMTP — leave empty to use email autoconfirm in dev (no emails sent)
+SMTP_HOST=
+SMTP_PORT=
+SMTP_USER=
+SMTP_PASS=
+SMTP_SENDER_NAME=${projectName}
+
+# Storage (MinIO for local dev)
+S3_ENDPOINT=http://localhost:9000
+S3_ACCESS_KEY=supatype
+S3_SECRET_KEY=supatype-secret
+
+# Self-host compose uses the same DATABASE_URL when Postgres is published on localhost:5432
+`
+}
+
+function seedTemplate(projectName: string): string {
+  return `import { sql } from "@supatype/cli/seed"
+
+// Connect using DATABASE_URL from environment
+const db = sql(
+  process.env["DATABASE_URL"] ??
+    "postgresql://supatype_admin:postgres@localhost:5432/${projectName}",
+)
+
+async function seed() {
+  console.log("Seeding ${projectName}...")
+
+  // TODO: insert seed data
+  // await db\`INSERT INTO users (email, name) VALUES ('admin@example.com', 'Admin')\`
+
+  await db.end()
+  console.log("Done.")
+}
+
+seed().catch((e) => {
+  console.error(e)
+  process.exit(1)
+})
+`
+}
+
+function gitignoreTemplate(): string {
+  return `.env
+node_modules/
+dist/
+.supatype/engine/
+# Local overrides — never commit
+supatype.local.config.ts
+supatype.local.config.js
+supatype.local.config.mjs
+# Generated by supatype push
+src/types/supatype.d.ts
+src/lib/supatype.ts
+`
+}

package/src/commands/keys.ts

@@ -0,0 +1,66 @@
+import type { Command } from "commander"
+import { readFileSync, existsSync } from "node:fs"
+import { resolve } from "node:path"
+import { signJwt } from "../jwt.js"
+
+export function registerKeys(program: Command): void {
+  program
+    .command("keys")
+    .description("Generate ANON_KEY and SERVICE_ROLE_KEY JWTs from your JWT_SECRET")
+    .option("--secret <secret>", "JWT secret (defaults to JWT_SECRET env var or value in .env)")
+    .option("--exp-years <years>", "Token expiry in years (default: 10)", "10")
+    .action((opts: { secret?: string; expYears: string }) => {
+      const secret = opts.secret ?? resolveSecret()
+      if (!secret) {
+        console.error(
+          "Error: JWT_SECRET not found. Set it in .env or pass --secret <value>",
+        )
+        process.exit(1)
+      }
+
+      const expYears = parseInt(opts.expYears, 10)
+      if (isNaN(expYears) || expYears < 1) {
+        console.error("Error: --exp-years must be a positive integer")
+        process.exit(1)
+      }
+
+      const now = Math.floor(Date.now() / 1000)
+      const exp = now + expYears * 365 * 24 * 60 * 60
+
+      const anonKey = signJwt({ iss: "supatype", role: "anon", iat: now, exp }, secret)
+      const serviceKey = signJwt({ iss: "supatype", role: "service_role", iat: now, exp }, secret)
+
+      console.log("\nGenerated keys (valid for", expYears, "years):\n")
+      console.log("ANON_KEY=" + anonKey)
+      console.log("SERVICE_ROLE_KEY=" + serviceKey)
+      console.log(
+        "\nAdd these to your .env file. Do not commit .env to source control.",
+      )
+    })
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+export function resolveSecret(): string | undefined {
+  // 1. Check environment variable
+  const fromEnv = process.env["JWT_SECRET"]
+  if (fromEnv) return fromEnv
+
+  // 2. Parse .env file in cwd
+  const envPath = resolve(process.cwd(), ".env")
+  if (!existsSync(envPath)) return undefined
+
+  try {
+    const contents = readFileSync(envPath, "utf8")
+    for (const line of contents.split("\n")) {
+      const trimmed = line.trim()
+      if (trimmed.startsWith("JWT_SECRET=")) {
+        const value = trimmed.slice("JWT_SECRET=".length).trim()
+        if (value && !value.startsWith("#")) return value
+      }
+    }
+  } catch {
+    // ignore read errors
+  }
+  return undefined
+}

package/src/commands/logs.ts

@@ -0,0 +1,58 @@
+/**
+ * supatype logs — tail aggregated logs from local Docker containers.
+ */
+import type { Command } from "commander"
+import { spawn } from "node:child_process"
+
+const SERVICES = ["postgres", "postgrest", "gotrue", "kong", "minio", "realtime", "studio"]
+
+export function registerLogs(program: Command): void {
+  program
+    .command("logs")
+    .description("Tail aggregated logs from local dev services")
+    .option("--service <name>", "Filter to a specific service")
+    .option("--since <duration>", "Show logs since duration (e.g., 5m, 1h)", "5m")
+    .option("-f, --follow", "Follow log output", true)
+    .action((opts: { service?: string; since?: string; follow?: boolean }) => {
+      const services = opts.service
+        ? [`supatype-${opts.service}`]
+        : SERVICES.map((s) => `supatype-${s}`)
+
+      if (opts.service && !SERVICES.includes(opts.service)) {
+        console.error(`Unknown service: ${opts.service}`)
+        console.error(`Available: ${SERVICES.join(", ")}`)
+        process.exit(1)
+      }
+
+      const args = ["compose", "logs"]
+      if (opts.follow) args.push("-f")
+      if (opts.since) args.push("--since", opts.since)
+      args.push("--tail", "100")
+
+      // If filtering by service, use docker logs for that container
+      if (opts.service) {
+        const containerArgs = ["logs"]
+        if (opts.follow) containerArgs.push("-f")
+        if (opts.since) containerArgs.push("--since", opts.since)
+        containerArgs.push("--tail", "100")
+        containerArgs.push(`supatype-${opts.service}`)
+
+        const child = spawn("docker", containerArgs, { stdio: "inherit" })
+        child.on("error", () => {
+          console.error("Docker not found. Ensure Docker is installed and running.")
+          process.exit(1)
+        })
+        return
+      }
+
+      // Aggregated logs via docker compose
+      const child = spawn("docker", args, {
+        stdio: "inherit",
+        cwd: process.cwd(),
+      })
+      child.on("error", () => {
+        console.error("Docker not found. Ensure Docker is installed and running.")
+        process.exit(1)
+      })
+    })
+}

package/src/commands/migrate-from-v1.ts

@@ -0,0 +1,131 @@
+import type { Command } from "commander"
+import { existsSync, readFileSync, writeFileSync } from "node:fs"
+import { basename, dirname, extname, join, resolve } from "node:path"
+import ts from "typescript"
+import { loadConfig } from "../config.js"
+import { schemaPathFromProject } from "../project-config.js"
+
+export function registerMigrateFromV1(program: Command): void {
+  program
+    .command("migrate-from-v1")
+    .description("Codemod runtime model() schema DSL into RFC v2 Model<> type aliases")
+    .option("--schema <path>", "Path to v1 schema file (defaults to supatype.config.ts schema)")
+    .option("--write", "Overwrite source file instead of creating .v2.ts sibling")
+    .action((opts: { schema?: string; write?: boolean }) => {
+      const cwd = process.cwd()
+      const cfg = loadConfig(cwd)
+      const schemaPath = opts.schema !== undefined
+        ? resolve(cwd, opts.schema)
+        : schemaPathFromProject(cfg, cwd)
+      if (!existsSync(schemaPath)) {
+        throw new Error(`Schema file not found: ${schemaPath}`)
+      }
+
+      const src = readFileSync(schemaPath, "utf8")
+      const sf = ts.createSourceFile(schemaPath, src, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+      const output = codemodSource(sf)
+      const outPath = opts.write
+        ? schemaPath
+        : join(dirname(schemaPath), basename(schemaPath).replace(extname(schemaPath), ".v2.ts"))
+
+      writeFileSync(outPath, output, "utf8")
+      console.log(`v2 schema written to ${outPath}`)
+      if (!opts.write) {
+        console.log("Review TODO comments and replace unknown mappings before using this file in production.")
+      }
+    })
+}
+
+export function codemodSource(sf: ts.SourceFile): string {
+  const lines: string[] = []
+  lines.push('import type { Model, UUID, Optional } from "@supatype/types"')
+  lines.push("")
+  lines.push("// TODO(v2-migration): verify each mapped type and access rule below.")
+  lines.push("")
+
+  for (const stmt of sf.statements) {
+    if (!ts.isVariableStatement(stmt)) continue
+    if (!(ts.getModifiers(stmt)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false)) continue
+
+    for (const decl of stmt.declarationList.declarations) {
+      if (!ts.isIdentifier(decl.name) || !decl.initializer) continue
+      const modelCall = extractModelCall(decl.initializer)
+      if (!modelCall) continue
+      const fields = extractFields(modelCall.config)
+      const modelType = renderModelType(decl.name.text, fields)
+      lines.push(modelType)
+      lines.push("")
+    }
+  }
+
+  if (lines.length <= 4) {
+    lines.push("// TODO(v2-migration): no model() declarations were detected in this file.")
+  }
+
+  return lines.join("\n")
+}
+
+function extractModelCall(node: ts.Expression): { config: ts.ObjectLiteralExpression } | null {
+  if (!ts.isCallExpression(node)) return null
+  if (!ts.isIdentifier(node.expression) || node.expression.text !== "model") return null
+  const config = node.arguments[1]
+  if (!config || !ts.isObjectLiteralExpression(config)) return null
+  return { config }
+}
+
+function extractFields(config: ts.ObjectLiteralExpression): Array<{ name: string; type: string }> {
+  const fieldsProp = config.properties.find(
+    (p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === "fields",
+  )
+  if (!fieldsProp || !ts.isPropertyAssignment(fieldsProp) || !ts.isObjectLiteralExpression(fieldsProp.initializer)) {
+    return []
+  }
+
+  const result: Array<{ name: string; type: string }> = []
+  for (const prop of fieldsProp.initializer.properties) {
+    if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue
+    result.push({
+      name: prop.name.text,
+      type: mapFieldInitializerToType(prop.initializer),
+    })
+  }
+  return result
+}
+
+function mapFieldInitializerToType(node: ts.Expression): string {
+  if (!ts.isCallExpression(node)) return "unknown // TODO(v2-migration): unsupported field expression"
+  if (!ts.isPropertyAccessExpression(node.expression)) return "unknown // TODO(v2-migration): unsupported field expression"
+  if (!ts.isIdentifier(node.expression.expression) || node.expression.expression.text !== "field") {
+    return "unknown // TODO(v2-migration): unsupported field expression"
+  }
+
+  const kind = node.expression.name.text
+  switch (kind) {
+    case "uuid":
+      return "UUID"
+    case "text":
+    case "slug":
+    case "email":
+    case "url":
+      return "string"
+    case "integer":
+    case "smallInt":
+    case "float":
+    case "decimal":
+      return "number"
+    case "boolean":
+      return "boolean"
+    case "richText":
+    case "json":
+      return "Record<string, unknown>"
+    default:
+      return "unknown // TODO(v2-migration): map field." + kind
+  }
+}
+
+function renderModelType(name: string, fields: Array<{ name: string; type: string }>): string {
+  const fieldsBlock = fields
+    .map((field) => `  ${field.name}: ${field.type}`)
+    .join("\n")
+  return `export type ${name} = Model<{\n${fieldsBlock}\n}>`
+}

package/src/commands/migrate.ts

@@ -0,0 +1,87 @@
+import type { Command } from "commander"
+import { createInterface } from "node:readline"
+import { loadConfig, loadSchemaAst } from "../config.js"
+import { connectionString, schemaPathFromProject } from "../project-config.js"
+import { ensureEngine, engineRequest } from "../engine-client.js"
+
+export function registerMigrate(program: Command): void {
+  // migrate — apply all pending migrations
+  program
+    .command("migrate")
+    .description("Apply pending migrations from the migration history")
+    .option("--connection <url>", "Database connection URL (overrides config)")
+    .action(async (opts: { connection?: string }) => {
+      const config = loadConfig()
+      const connection = opts.connection ?? connectionString(config)
+
+      await ensureEngine()
+      const result = await engineRequest<{ message?: string }>("/migrations", {
+        database_url: connection,
+        schema: "public",
+        action: "pending",
+      })
+      console.log(result.message ?? "Migrations applied.")
+    })
+
+  // rollback — undo the last applied migration
+  program
+    .command("rollback")
+    .description("Roll back the last applied migration")
+    .option("--connection <url>", "Database connection URL (overrides config)")
+    .action(async (opts: { connection?: string }) => {
+      const config = loadConfig()
+      const connection = opts.connection ?? connectionString(config)
+
+      await ensureEngine()
+      const result = await engineRequest<{ message?: string }>("/migrations", {
+        database_url: connection,
+        schema: "public",
+        action: "rollback",
+      })
+      console.log(result.message ?? "Rolled back.")
+    })
+
+  // reset — drop all tables and re-apply from scratch
+  program
+    .command("reset")
+    .description(
+      "Drop all managed tables and re-apply the schema from scratch (destructive)",
+    )
+    .option("--yes", "Skip confirmation prompt")
+    .option("--connection <url>", "Database connection URL (overrides config)")
+    .action(async (opts: { yes?: boolean; connection?: string }) => {
+      if (!opts.yes) {
+        const confirmed = await confirm(
+          "This will DROP all managed tables and re-apply the schema. Proceed? [y/N] ",
+        )
+        if (!confirmed) {
+          console.log("Aborted.")
+          return
+        }
+      }
+
+      const config = loadConfig()
+      const connection = opts.connection ?? connectionString(config)
+      const cwd = process.cwd()
+
+      await ensureEngine()
+      const ast = loadSchemaAst(schemaPathFromProject(config, cwd), cwd)
+      const result = await engineRequest<{ message?: string }>("/push", {
+        ast,
+        database_url: connection,
+        schema: "public",
+        force: true,
+      })
+      console.log(result.message ?? "Reset complete.")
+    })
+}
+
+async function confirm(prompt: string): Promise<boolean> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close()
+      resolve(answer.toLowerCase() === "y")
+    })
+  })
+}