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

package/src/commands/init.ts

@@ -1,18 +1,41 @@
 import type { Command } from "commander"
-import { existsSync, mkdirSync, writeFileSync } from "node:fs"
-import { resolve, join } from "node:path"
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { resolve, join, dirname } from "node:path"
+import { fileURLToPath } from "node:url"
+import { fetchAllLatestVersions } from "../binary-cache.js"
 
 export { scaffold }
 
-// ─── Markers used by `supatype app add / remove` ─────────────────────────────
+// ─── 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")
-    .action((name?: string) => {
+    .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()
 
@@ -23,19 +46,37 @@ export function registerInit(program: Command): void {
 
       if (name) mkdirSync(dir, { recursive: true })
 
-      scaffold(dir, projectName)
+      let versions: Record<string, string> = {}
+      try {
+        console.log("Fetching latest component versions from CDN...")
+        versions = await fetchAllLatestVersions()
+      } catch {
+        // Non-fatal: scaffold with placeholder versions; user can run `supatype update`.
+      }
+
+      scaffold(dir, projectName, opts.mode as "dev" | "standalone", versions)
 
       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")
+      console.log("  npm install")
+      console.log("  supatype keys")
+      console.log("  supatype dev          # native Postgres + supatype-server")
+      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): void {
+function scaffold(dir: string, projectName: string, mode: "dev" | "standalone" = "dev", versions: Record<string, string> = {}): void {
   const write = (rel: string, content: string) => {
     const full = join(dir, rel)
     mkdirSync(resolve(full, ".."), { recursive: true })
@@ -43,69 +84,120 @@ function scaffold(dir: string, projectName: string): void {
     console.log(`  created  ${rel}`)
   }
 
-  write("supatype.config.ts", configTemplate(projectName))
+  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, versions))
   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("seeds/.gitkeep", "")
+  write("public/.gitkeep", "")
   write(".gitignore", gitignoreTemplate())
 }
 
 // ─── Templates ───────────────────────────────────────────────────────────────
 
-function configTemplate(projectName: string): string {
+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", versions: Record<string, string> = {}): string {
+  const domainField =
+    mode === "standalone"
+      ? `    domain: "",  // e.g. "api.example.com" for ACME TLS\n`
+      : ""
+  const v = (key: string, fallback: string) => versions[key] ?? fallback
   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",
+  project: { name: "${projectName}" },
+  provider: "native",
+  // provider: "docker"  // full self-host Compose stack (Kong :18473)
+  database: {
+    provider: "native",
+  },
+  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)
+  },
+  versions: {
+    engine: "${v("engine", "latest")}",
+    server: "${v("server", "latest")}",
+    postgres: "${v("postgres", "latest")}",
+    deno: "${v("deno", "latest")}",
   },
-  // 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",
-  //   },
-  // },
+  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 { 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 }),
-  },
+  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: access.public(),
-    create: access.public(),
-    update: access.owner("id"),
-    delete: access.role("admin"),
-  },
-  options: { timestamps: true },
-})
+    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://postgres:postgres@localhost:5432/${projectName}
+  return `DATABASE_URL=postgresql://supatype_admin:postgres@localhost:5432/${projectName}
+POSTGRES_USER=supatype_admin
 POSTGRES_PASSWORD=postgres
 POSTGRES_DB=${projectName}
 
@@ -128,369 +220,8 @@ SMTP_SENDER_NAME=${projectName}
 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
+# Self-host compose uses the same DATABASE_URL when Postgres is published on localhost:5432
 `
 }
 
@@ -500,7 +231,7 @@ function seedTemplate(projectName: string): string {
 // Connect using DATABASE_URL from environment
 const db = sql(
   process.env["DATABASE_URL"] ??
-    "postgresql://postgres:postgres@localhost:5432/${projectName}",
+    "postgresql://supatype_admin:postgres@localhost:5432/${projectName}",
 )
 
 async function seed() {
@@ -525,6 +256,10 @@ function gitignoreTemplate(): string {
 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