@supatype/cli 0.1.0-alpha.6

package/src/commands/generate.ts

@@ -0,0 +1,31 @@
+import type { Command } from "commander"
+import { loadConfig, loadSchemaAst } from "../config.js"
+import { ensureEngine, invokeEngine } from "../engine.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 connection = opts.connection ?? config.connection
+
+      await ensureEngine()
+      console.log("Loading schema...")
+      const ast = loadSchemaAst(config.schema, cwd)
+
+      const args = ["generate", "--connection", connection]
+      if (config.output?.types) args.push("--types", config.output.types)
+      if (config.output?.client) args.push("--client", config.output.client)
+
+      const result = invokeEngine(args, JSON.stringify(ast))
+      if (result.exitCode !== 0) {
+        console.error(result.stderr || result.stdout)
+        process.exit(1)
+      }
+
+      console.log(result.stdout || "Types generated.")
+    })
+}

package/src/commands/init.ts

@@ -0,0 +1,532 @@
+import type { Command } from "commander"
+import { existsSync, mkdirSync, writeFileSync } from "node:fs"
+import { resolve, join } from "node:path"
+
+export { scaffold }
+
+// ─── Markers used by `supatype app add / remove` ─────────────────────────────
+export const APP_COMPOSE_MARKER = "  # ─── App service (run: supatype app add) ───"
+export const KONG_APP_MARKER = "  # ─── App fallback route (run: supatype app add) ───"
+
+export function registerInit(program: Command): void {
+  program
+    .command("init [name]")
+    .description("Scaffold a new Supatype project")
+    .action((name?: string) => {
+      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)
+
+      console.log(`\nSupatype project ready${name ? ` in ${name}/` : ""}.\n`)
+      console.log("Next steps:")
+      if (name) console.log(`  cd ${name}`)
+      console.log("  pnpm install")
+      console.log("  supatype keys       # generate ANON_KEY + SERVICE_ROLE_KEY, add to .env")
+      console.log("  supatype dev        # start local Postgres + PgBouncer + GoTrue + PostgREST")
+      console.log("  supatype push       # apply schema + generate types\n")
+    })
+}
+
+function scaffold(dir: string, projectName: string): 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}`)
+  }
+
+  write("supatype.config.ts", configTemplate(projectName))
+  write("schema/index.ts", schemaTemplate())
+  write(".env", envTemplate(projectName))
+  write("docker-compose.yml", dockerComposeTemplate(projectName))
+  write(".supatype/kong.yml", kongTemplate())
+  write(".supatype/pgbouncer.ini", pgbouncerIniTemplate())
+  write(".supatype/userlist.txt", pgbouncerUserlistTemplate())
+  write("seed.ts", seedTemplate(projectName))
+  write(".gitignore", gitignoreTemplate())
+}
+
+// ─── Templates ───────────────────────────────────────────────────────────────
+
+function configTemplate(projectName: string): string {
+  return `import { defineConfig } from "@supatype/cli"
+
+export default defineConfig({
+  connection:
+    process.env["DATABASE_URL"] ??
+    "postgresql://postgres:postgres@localhost:5432/${projectName}",
+  schema: "./schema/index.ts",
+  output: {
+    types: "./src/types/supatype.d.ts",
+    client: "./src/lib/supatype.ts",
+  },
+  // Self-hosted production deployment (run: supatype self-host setup)
+  // selfHost: {
+  //   domain: "${projectName}.example.com",
+  //   app: {
+  //     dockerfile: "./Dockerfile",
+  //     port: 3000,
+  //   },
+  //   ssl: {
+  //     provider: "caddy",
+  //     email: "you@example.com",
+  //   },
+  // },
+})
+`
+}
+
+function schemaTemplate(): string {
+  return `import { model, field, access } from "@supatype/schema"
+
+export const User = model("user", {
+  fields: {
+    id: field.uuid({ required: true, default: { kind: "genRandomUuid" } }),
+    email: field.email({ required: true, unique: true }),
+    name: field.text({ required: true }),
+  },
+  access: {
+    read: access.public(),
+    create: access.public(),
+    update: access.owner("id"),
+    delete: access.role("admin"),
+  },
+  options: { timestamps: true },
+})
+`
+}
+
+function envTemplate(projectName: string): string {
+  return `DATABASE_URL=postgresql://postgres:postgres@localhost:5432/${projectName}
+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
+`
+}
+
+function dockerComposeTemplate(projectName: string): string {
+  return `services:
+  db:
+    image: supatype/postgres:17-latest
+    environment:
+      POSTGRES_PASSWORD: \${POSTGRES_PASSWORD:-postgres}
+      POSTGRES_DB: \${POSTGRES_DB:-${projectName}}
+    ports:
+      - "5432:5432"
+    volumes:
+      - db-data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 20
+
+  pgbouncer:
+    image: pgbouncer/pgbouncer:latest
+    volumes:
+      - ./.supatype/pgbouncer.ini:/etc/pgbouncer/pgbouncer.ini:ro
+      - ./.supatype/userlist.txt:/etc/pgbouncer/userlist.txt:ro
+    depends_on:
+      db:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "pg_isready", "-h", "localhost", "-p", "6432", "-U", "postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+
+  gotrue:
+    image: supatype/auth:v1.0.0
+    environment:
+      GOTRUE_API_HOST: 0.0.0.0
+      GOTRUE_API_PORT: 9999
+      GOTRUE_DB_DRIVER: postgres
+      GOTRUE_DB_DATABASE_URL: "postgres://postgres:\${POSTGRES_PASSWORD:-postgres}@pgbouncer:6432/\${POSTGRES_DB:-${projectName}}?search_path=auth"
+      GOTRUE_SITE_URL: \${SITE_URL:-http://localhost:3000}
+      GOTRUE_JWT_SECRET: \${JWT_SECRET:-super-secret-jwt-token-change-in-production}
+      GOTRUE_JWT_EXP: 3600
+      GOTRUE_JWT_AUD: authenticated
+      GOTRUE_JWT_DEFAULT_GROUP_NAME: authenticated
+      GOTRUE_JWT_ADMIN_ROLES: service_role
+      # Email autoconfirm — set to false and configure SMTP for production
+      GOTRUE_MAILER_AUTOCONFIRM: \${GOTRUE_MAILER_AUTOCONFIRM:-true}
+      GOTRUE_SMTP_HOST: \${SMTP_HOST:-}
+      GOTRUE_SMTP_PORT: \${SMTP_PORT:-587}
+      GOTRUE_SMTP_USER: \${SMTP_USER:-}
+      GOTRUE_SMTP_PASS: \${SMTP_PASS:-}
+      GOTRUE_SMTP_SENDER_NAME: \${SMTP_SENDER_NAME:-${projectName}}
+      GOTRUE_MAILER_URLPATHS_CONFIRMATION: /auth/v1/verify
+      GOTRUE_MAILER_URLPATHS_RECOVERY: /auth/v1/verify
+      GOTRUE_MAILER_URLPATHS_EMAIL_CHANGE: /auth/v1/verify
+      GOTRUE_MAILER_URLPATHS_INVITE: /auth/v1/verify
+      GOTRUE_DISABLE_SIGNUP: \${DISABLE_SIGNUP:-false}
+    ports:
+      - "9999:9999"
+    depends_on:
+      pgbouncer:
+        condition: service_healthy
+
+  postgrest:
+    image: postgrest/postgrest:v12.2.8
+    environment:
+      PGRST_DB_URI: postgresql://authenticator:\${POSTGRES_PASSWORD:-postgres}@pgbouncer:6432/\${POSTGRES_DB:-${projectName}}
+      PGRST_DB_SCHEMA: public
+      PGRST_DB_ANON_ROLE: anon
+      PGRST_JWT_SECRET: \${JWT_SECRET:-super-secret-jwt-token-change-in-production}
+      PGRST_DB_EXTRA_SEARCH_PATH: public,extensions
+      PGRST_DB_POOL: 3
+    ports:
+      - "3000:3000"
+    depends_on:
+      pgbouncer:
+        condition: service_healthy
+
+  minio:
+    image: minio/minio:RELEASE.2024-11-07T00-52-20Z
+    command: server /data --console-address ":9001"
+    environment:
+      MINIO_ROOT_USER: supatype
+      MINIO_ROOT_PASSWORD: supatype-secret
+    ports:
+      - "9000:9000"
+      - "9001:9001"
+    volumes:
+      - minio-data:/data
+    healthcheck:
+      test: ["CMD", "mc", "ready", "local"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+
+  storage:
+    image: supatype/storage:latest
+    environment:
+      PORT: 5000
+      DATABASE_URL: "postgresql://postgres:\${POSTGRES_PASSWORD:-postgres}@pgbouncer:6432/\${POSTGRES_DB:-${projectName}}"
+      JWT_SECRET: \${JWT_SECRET:-super-secret-jwt-token-change-in-production}
+      S3_ENDPOINT: http://minio:9000
+      S3_REGION: us-east-1
+      S3_ACCESS_KEY: supatype
+      S3_SECRET_KEY: supatype-secret
+      S3_FORCE_PATH_STYLE: "true"
+    ports:
+      - "5000:5000"
+    depends_on:
+      pgbouncer:
+        condition: service_healthy
+      minio:
+        condition: service_healthy
+
+  realtime:
+    image: supatype/realtime:latest
+    environment:
+      PORT: 4000
+      DATABASE_URL: "postgresql://postgres:\${POSTGRES_PASSWORD:-postgres}@pgbouncer:6432/\${POSTGRES_DB:-${projectName}}"
+      JWT_SECRET: \${JWT_SECRET:-super-secret-jwt-token-change-in-production}
+      REPLICATION_MODE: RLS
+      REPLICATION_POLL_INTERVAL: 100
+      SECURE_CHANNELS: "true"
+      SLOT_NAME: realtime_slot
+    ports:
+      - "4000:4000"
+    depends_on:
+      pgbouncer:
+        condition: service_healthy
+
+  studio:
+    image: supatype/studio:latest
+    ports:
+      - "3002:3002"
+
+  kong:
+    image: kong:3.6
+    environment:
+      KONG_DATABASE: "off"
+      KONG_DECLARATIVE_CONFIG: /etc/kong/kong.yml
+      KONG_PROXY_ACCESS_LOG: /dev/stdout
+      KONG_ADMIN_ACCESS_LOG: /dev/stdout
+      KONG_PROXY_ERROR_LOG: /dev/stderr
+      KONG_ADMIN_ERROR_LOG: /dev/stderr
+    volumes:
+      - ./.supatype/kong.yml:/etc/kong/kong.yml:ro
+    ports:
+      - "8000:8000"
+    depends_on:
+      - postgrest
+      - gotrue
+      - storage
+      - realtime
+      - studio
+
+${APP_COMPOSE_MARKER}
+  # app:
+  #   build:
+  #     context: .
+  #     dockerfile: ./Dockerfile
+  #   ports:
+  #     - "3000:3000"
+  #   environment:
+  #     SUPATYPE_URL: http://kong:8000
+  #     SUPATYPE_ANON_KEY: \${ANON_KEY}
+  #     SUPATYPE_SERVICE_ROLE_KEY: \${SERVICE_ROLE_KEY}
+  #   volumes:
+  #     - .:/app
+  #     - /app/node_modules
+  #   depends_on:
+  #     kong:
+  #       condition: service_healthy
+
+volumes:
+  db-data:
+  minio-data:
+`
+}
+
+function kongTemplate(): string {
+  return `_format_version: "3.0"
+
+services:
+  - name: rest-v1
+    url: http://postgrest:3000
+    routes:
+      - name: rest-v1-all
+        strip_path: true
+        paths:
+          - /rest/v1/
+    plugins:
+      - name: cors
+        config:
+          origins:
+            - "*"
+          methods:
+            - GET
+            - POST
+            - PATCH
+            - DELETE
+            - OPTIONS
+          headers:
+            - Authorization
+            - Content-Type
+            - apikey
+            - Prefer
+          credentials: true
+
+  - name: graphql-v1
+    url: http://postgrest:3000/rpc/graphql
+    routes:
+      - name: graphql-v1-all
+        strip_path: true
+        paths:
+          - /graphql/v1
+    plugins:
+      - name: cors
+        config:
+          origins:
+            - "*"
+          methods:
+            - GET
+            - POST
+            - OPTIONS
+          headers:
+            - Authorization
+            - Content-Type
+            - apikey
+          credentials: true
+
+  - name: auth-v1
+    url: http://gotrue:9999
+    routes:
+      - name: auth-v1-all
+        strip_path: true
+        paths:
+          - /auth/v1/
+    plugins:
+      - name: cors
+        config:
+          origins:
+            - "*"
+          methods:
+            - GET
+            - POST
+            - PUT
+            - DELETE
+            - OPTIONS
+          headers:
+            - Authorization
+            - Content-Type
+            - apikey
+          credentials: true
+
+  - name: storage-v1
+    url: http://storage:5000
+    routes:
+      - name: storage-v1-all
+        strip_path: true
+        paths:
+          - /storage/v1/
+    plugins:
+      - name: cors
+        config:
+          origins:
+            - "*"
+          methods:
+            - GET
+            - POST
+            - PUT
+            - DELETE
+            - OPTIONS
+          headers:
+            - Authorization
+            - Content-Type
+            - apikey
+            - x-upsert
+          credentials: true
+
+  - name: realtime-v1
+    url: http://realtime:4000
+    routes:
+      - name: realtime-v1-all
+        strip_path: true
+        paths:
+          - /realtime/v1/
+        protocols:
+          - http
+          - https
+          - ws
+          - wss
+    plugins:
+      - name: cors
+        config:
+          origins:
+            - "*"
+          methods:
+            - GET
+            - OPTIONS
+          headers:
+            - Authorization
+            - Content-Type
+            - apikey
+          credentials: true
+
+  - name: studio
+    url: http://studio:3002
+    routes:
+      - name: studio-all
+        strip_path: true
+        paths:
+          - /studio/
+    plugins:
+      - name: cors
+        config:
+          origins:
+            - "*"
+          methods:
+            - GET
+            - POST
+            - OPTIONS
+          headers:
+            - Authorization
+            - Content-Type
+          credentials: true
+
+${KONG_APP_MARKER}
+  # - name: app
+  #   url: http://app:3000
+  #   routes:
+  #     - name: app-root
+  #       paths:
+  #         - /
+  #       strip_path: false
+`
+}
+
+function pgbouncerIniTemplate(): string {
+  return `[databases]
+# Forward all databases to Postgres (Docker service name: db)
+* = host=db port=5432
+
+[pgbouncer]
+listen_addr = 0.0.0.0
+listen_port = 6432
+# trust = accept any client on the internal Docker network (safe for local dev)
+auth_type = trust
+auth_file = /etc/pgbouncer/userlist.txt
+pool_mode = transaction
+default_pool_size = 20
+max_db_connections = 60
+max_client_conn = 100
+# Required for PostgREST compatibility
+server_reset_query = DEALLOCATE ALL
+ignore_startup_parameters = extra_float_digits
+`
+}
+
+function pgbouncerUserlistTemplate(): string {
+  return `# PgBouncer userlist — auth_type = trust for local dev, so passwords here are unused.
+# For production, this file is regenerated by: supatype self-host setup
+`
+}
+
+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://postgres: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/
+# 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)
+      })
+    })
+}