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

package/src/runtime-routes.ts

@@ -0,0 +1,291 @@
+export interface RuntimeRoute {
+  name: string
+  serviceName: string
+  serviceUrl: string
+  paths: string[]
+  stripPath?: boolean
+  protocols?: string[]
+  engineProtected?: boolean
+  /** Route /graphql/v1 to PostgREST /rpc/graphql with graphql_public Content-Profile. */
+  graphqlPostgrest?: boolean
+}
+
+export interface RuntimeRouteOptions {
+  appUpstream?: string
+  staticAppServiceUrl?: string
+  /** Compose self-host: supatype-server container (functions proxy). */
+  functionsServiceUrl?: string
+  /**
+   * Self-host Compose: Kong forwards API traffic to supatype-server (unified gateway),
+   * which proxies to internal services — same model as `supatype dev`.
+   */
+  unifiedGateway?: boolean
+  /** Studio UI upstream (default: in-compose `studio:3002`). */
+  studioServiceUrl?: string
+  /**
+   * Strip `/studio/` before proxying to the Studio upstream.
+   * False for host Vite dev (`host.docker.internal`) where `base` is `/studio/`.
+   */
+  studioStripPath?: boolean
+}
+
+const DEFAULT_STUDIO_SERVICE_URL = "http://studio:3002"
+
+function studioServiceUrl(opts: RuntimeRouteOptions): string {
+  const url = opts.studioServiceUrl?.trim()
+  return url && url.length > 0 ? url : DEFAULT_STUDIO_SERVICE_URL
+}
+
+function studioStripPath(opts: RuntimeRouteOptions): boolean {
+  return opts.studioStripPath !== false
+}
+
+const SERVER_GATEWAY = "http://server:9999"
+
+/**
+ * Kong routes when self-host uses supatype-server as the single API gateway.
+ */
+function runtimeRouteSpecUnified(opts: RuntimeRouteOptions): RuntimeRoute[] {
+  const studioUrl = studioServiceUrl(opts)
+  const stripStudio = studioStripPath(opts)
+  return [
+    {
+      name: "rest-v1",
+      serviceName: "supatype-server-rest",
+      serviceUrl: SERVER_GATEWAY,
+      paths: ["/rest/v1/"],
+      stripPath: false,
+    },
+    {
+      name: "auth-v1",
+      serviceName: "supatype-server-auth",
+      serviceUrl: SERVER_GATEWAY,
+      paths: ["/auth/v1/"],
+      stripPath: false,
+    },
+    {
+      name: "admin-v1",
+      serviceName: "supatype-server-admin",
+      serviceUrl: SERVER_GATEWAY,
+      paths: ["/admin/v1/"],
+      stripPath: false,
+    },
+    {
+      name: "storage-v1",
+      serviceName: "supatype-server-storage",
+      serviceUrl: SERVER_GATEWAY,
+      paths: ["/storage/v1/"],
+      stripPath: false,
+    },
+    {
+      name: "realtime-v1",
+      serviceName: "supatype-server-realtime",
+      serviceUrl: SERVER_GATEWAY,
+      paths: ["/realtime/v1/"],
+      stripPath: false,
+      protocols: ["http", "https"],
+    },
+    {
+      name: "functions-v1",
+      serviceName: "supatype-server-functions",
+      serviceUrl: SERVER_GATEWAY,
+      paths: ["/functions/v1/"],
+      stripPath: false,
+    },
+    {
+      name: "graphql-v1",
+      serviceName: "postgrest-graphql",
+      serviceUrl: "http://postgrest:3000/rpc/graphql",
+      paths: ["/graphql/v1"],
+      stripPath: true,
+      graphqlPostgrest: true,
+    },
+    {
+      name: "studio-config-route",
+      serviceName: "supatype-server-studio-config",
+      serviceUrl: SERVER_GATEWAY,
+      paths: ["/studio-config"],
+      stripPath: false,
+    },
+    {
+      name: "sql-route",
+      serviceName: "supatype-server-sql",
+      serviceUrl: SERVER_GATEWAY,
+      paths: ["/sql"],
+      stripPath: false,
+    },
+    {
+      name: "studio-auth",
+      serviceName: "supatype-server-studio-auth",
+      serviceUrl: SERVER_GATEWAY,
+      paths: ["/studio/auth/"],
+      stripPath: false,
+    },
+    {
+      name: "studio-proxy",
+      serviceName: "supatype-server-studio-proxy",
+      serviceUrl: SERVER_GATEWAY,
+      paths: ["/studio/proxy/"],
+      stripPath: false,
+    },
+    {
+      name: "studio-exact",
+      serviceName: "studio-exact",
+      serviceUrl: studioUrl,
+      paths: ["~/studio$"],
+      stripPath: stripStudio,
+    },
+    {
+      name: "studio",
+      serviceName: "studio",
+      serviceUrl: studioUrl,
+      paths: ["/studio/"],
+      stripPath: stripStudio,
+    },
+    {
+      name: "app-root",
+      serviceName: "supatype-server-app",
+      serviceUrl: SERVER_GATEWAY,
+      paths: ["/"],
+      stripPath: false,
+    },
+  ]
+}
+
+/**
+ * Legacy split-stack routes (PostgREST/storage/realtime directly from Kong).
+ * Kept for tests or explicit opt-out only — self-host uses unifiedGateway.
+ */
+function runtimeRouteSpecSplit(opts: RuntimeRouteOptions): RuntimeRoute[] {
+  const studioUrl = studioServiceUrl(opts)
+  const stripStudio = studioStripPath(opts)
+  const routes: RuntimeRoute[] = [
+    {
+      name: "rest-v1",
+      serviceName: "rest-v1",
+      serviceUrl: "http://postgrest:3000",
+      paths: ["/rest/v1/"],
+      stripPath: true,
+    },
+    {
+      name: "auth-v1",
+      serviceName: "auth-v1",
+      serviceUrl: "http://server:9999",
+      paths: ["/auth/v1/"],
+      stripPath: true,
+    },
+    {
+      name: "admin-v1",
+      serviceName: "admin-v1",
+      serviceUrl: "http://server:9999",
+      paths: ["/admin/v1/"],
+      stripPath: false,
+    },
+    {
+      name: "storage-v1",
+      serviceName: "storage-v1",
+      serviceUrl: "http://storage:5000",
+      paths: ["/storage/v1/"],
+      stripPath: true,
+    },
+    {
+      name: "realtime-v1",
+      serviceName: "realtime-v1",
+      serviceUrl: "http://realtime:4000",
+      paths: ["/realtime/v1/"],
+      stripPath: true,
+      protocols: ["http", "https"],
+    },
+    {
+      name: "functions-v1",
+      serviceName: "functions-v1",
+      serviceUrl: opts.functionsServiceUrl?.trim() || "http://server:9999",
+      paths: ["/functions/v1/"],
+      stripPath: false,
+    },
+    {
+      name: "graphql-v1",
+      serviceName: "postgrest-graphql",
+      serviceUrl: "http://postgrest:3000/rpc/graphql",
+      paths: ["/graphql/v1"],
+      stripPath: true,
+      graphqlPostgrest: true,
+    },
+    {
+      name: "studio-auth",
+      serviceName: "auth-v1",
+      serviceUrl: "http://server:9999",
+      paths: ["/studio/auth/"],
+      stripPath: false,
+    },
+    {
+      name: "studio-proxy",
+      serviceName: "auth-v1",
+      serviceUrl: "http://server:9999",
+      paths: ["/studio/proxy/"],
+      stripPath: false,
+    },
+    {
+      name: "studio-exact",
+      serviceName: "studio-exact",
+      serviceUrl: studioUrl,
+      paths: ["~/studio$"],
+      stripPath: stripStudio,
+    },
+    {
+      name: "studio",
+      serviceName: "studio",
+      serviceUrl: studioUrl,
+      paths: ["/studio/"],
+      stripPath: stripStudio,
+    },
+    {
+      name: "studio-config-route",
+      serviceName: "engine-studio-config",
+      serviceUrl: "http://engine:7500",
+      paths: ["/studio-config"],
+      engineProtected: true,
+    },
+    {
+      name: "sql-route",
+      serviceName: "engine-sql",
+      serviceUrl: "http://engine:7500",
+      paths: ["/sql"],
+      engineProtected: true,
+    },
+  ]
+
+  const staticServiceUrl = opts.staticAppServiceUrl?.trim()
+  if (staticServiceUrl && staticServiceUrl.length > 0) {
+    routes.push({
+      name: "app-root",
+      serviceName: "app-root",
+      serviceUrl: staticServiceUrl,
+      paths: ["/"],
+      stripPath: false,
+    })
+    return routes
+  }
+
+  if (opts.appUpstream && opts.appUpstream.trim().length > 0) {
+    routes.push({
+      name: "app-root",
+      serviceName: "app-root",
+      serviceUrl: opts.appUpstream.trim(),
+      paths: ["/"],
+      stripPath: false,
+    })
+  }
+
+  return routes
+}
+
+/**
+ * Shared route contract used by local/self-host renderers.
+ */
+export function runtimeRouteSpec(opts: RuntimeRouteOptions = {}): RuntimeRoute[] {
+  if (opts.unifiedGateway) {
+    return runtimeRouteSpecUnified(opts)
+  }
+  return runtimeRouteSpecSplit(opts)
+}

package/src/schema-ast-v2.ts

@@ -0,0 +1,324 @@
+/**
+ * AST v2 wire format — canonical types and emitters.
+ * Parsers build {@link ParsedField}; only `emitField` / `emitModel` / `emitSchema` produce JSON.
+ */
+
+export const AST_VERSION = 2 as const
+
+export type DefaultAst =
+  | { kind: "value"; value: string | number | boolean | null }
+  | { kind: "now" }
+  | { kind: "genRandomUuid" }
+  | { kind: "expression"; expr: string }
+
+export interface DbFieldAnnotations {
+  pgType?: string
+  unique?: boolean
+  index?: boolean
+  foreignKey?: string
+  serverGenerated?: boolean
+  elementType?: string
+}
+
+export interface PlatformFieldAnnotations {
+  editor?: string
+  readOnly?: boolean
+}
+
+export interface FieldAnnotations {
+  db?: DbFieldAnnotations
+  platform?: PlatformFieldAnnotations
+}
+
+/** Kernel facts only — never db/platform keys at this layer. */
+export interface KernelFieldFacts {
+  required?: boolean
+  primaryKey?: boolean
+  default?: DefaultAst
+  localized?: boolean
+  cardinality?: string
+  target?: string
+  values?: string[]
+  from?: string
+  sources?: string[]
+  template?: string
+  bucket?: string
+  accessMode?: string
+  geoType?: string
+  srid?: number
+  dimensions?: number
+  blocks?: BlockDefinitionAst[]
+  check?: string
+  precision?: number
+  scale?: number
+  references?: string
+  through?: string
+  onDelete?: string
+  onUpdate?: string
+  uniqueFk?: boolean
+  plugin?: string
+  fieldType?: string
+  tsType?: string
+  index?: boolean
+}
+
+/** Internal parse result — not serialized. */
+export interface ParsedField {
+  kind: string
+  kernel: KernelFieldFacts
+  db: DbFieldAnnotations
+  platform: PlatformFieldAnnotations
+}
+
+export type FieldAstV2 = {
+  kind: string
+  annotations?: FieldAnnotations
+} & Record<string, unknown>
+
+export interface BlockDefinitionAst {
+  name: string
+  label?: string
+  icon?: string
+  fields: Record<string, FieldAstV2>
+}
+
+export interface ModelAstV2 {
+  name: string
+  fields: Record<string, FieldAstV2>
+  options: Record<string, unknown>
+  annotations: {
+    db: { tableName: string; indexes: unknown[] }
+    platform: { access: Record<string, unknown> }
+  }
+}
+
+export interface ExtractedStorageBucketAst {
+  id: string
+  public: boolean
+  accessMode?: "public" | "private" | "custom"
+  allowedMimeTypes?: string[]
+  fileSizeLimit?: number
+  access?: Record<string, unknown>
+  s3BucketPolicy?: string
+}
+
+export interface ExtractedSchemaAstV2 {
+  astVersion: typeof AST_VERSION
+  models: ModelAstV2[]
+  storageBuckets?: ExtractedStorageBucketAst[]
+  locales?: string[]
+  defaultLocale?: string
+}
+
+const DEFAULT_DB_BY_KIND: Record<string, Partial<DbFieldAnnotations>> = {
+  text: { pgType: "TEXT" },
+  richText: { pgType: "JSONB" },
+  integer: { pgType: "INTEGER" },
+  smallInt: { pgType: "SMALLINT" },
+  bigInt: { pgType: "BIGINT" },
+  float: { pgType: "DOUBLE PRECISION" },
+  boolean: { pgType: "BOOLEAN" },
+  datetime: { pgType: "TIMESTAMPTZ" },
+  date: { pgType: "DATE" },
+  timestamp: { pgType: "TIMESTAMP WITH TIME ZONE" },
+  uuid: { pgType: "UUID" },
+  email: { pgType: "TEXT" },
+  url: { pgType: "TEXT" },
+  slug: { pgType: "TEXT" },
+  enum: { pgType: "TEXT" },
+  json: { pgType: "JSONB" },
+  decimal: { pgType: "TEXT" },
+  bytes: { pgType: "BYTEA" },
+  serial: { pgType: "SERIAL" },
+  bigSerial: { pgType: "BIGSERIAL" },
+  money: { pgType: "TEXT" },
+  ip: { pgType: "TEXT" },
+  cidr: { pgType: "TEXT" },
+  macaddr: { pgType: "TEXT" },
+  xml: { pgType: "TEXT" },
+  tsQuery: { pgType: "TEXT" },
+  tsVector: { pgType: "TEXT" },
+  color: { pgType: "TEXT" },
+  array: { pgType: "ARRAY" },
+  image: { pgType: "JSONB" },
+  file: { pgType: "JSONB" },
+  geo: { pgType: "GEOGRAPHY" },
+  vector: { pgType: "VECTOR" },
+  blocks: { pgType: "JSONB" },
+}
+
+const DEFAULT_PLATFORM_BY_KIND: Record<string, Partial<PlatformFieldAnnotations>> = {
+  richText: { editor: "rich" },
+}
+
+const COMPOSITE_KINDS = new Set(["timestamps", "publishable", "softDelete"])
+
+function hasKeys(obj: Record<string, unknown>): boolean {
+  return Object.keys(obj).length > 0
+}
+
+function stripUndefined<T extends Record<string, unknown>>(obj: T): Partial<T> {
+  const out: Record<string, unknown> = {}
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== undefined) out[k] = v
+  }
+  return out as Partial<T>
+}
+
+/** Start a parsed field with kind defaults for db/platform namespaces. */
+export function defaultPgTypeForKind(kind: string): string {
+  return DEFAULT_DB_BY_KIND[kind]?.pgType ?? "TEXT"
+}
+
+/** Flat wire shape for fields nested inside `blocks` definitions (engine FieldAst serde). */
+export function emitBlockNestedField(field: FieldAstV2): FieldAstV2 {
+  const annotations = (field.annotations ?? {}) as FieldAnnotations
+  const db = annotations.db ?? {}
+  const platform = annotations.platform ?? {}
+
+  const wire: FieldAstV2 = {
+    kind: field.kind,
+    pgType: db.pgType ?? defaultPgTypeForKind(String(field.kind)),
+    required: field.required ?? false,
+    unique: db.unique ?? false,
+    localized: field.localized ?? false,
+  }
+
+  if (platform.readOnly) wire.readOnly = true
+  if (field.primaryKey) wire.primaryKey = true
+  if (field.default !== undefined) wire.default = field.default
+  if (field.from !== undefined) wire.from = field.from
+  if (field.values !== undefined) wire.values = field.values
+  if (field.bucket !== undefined) wire.bucket = field.bucket
+  if (field.accessMode !== undefined) wire.accessMode = field.accessMode
+  if (field.geoType !== undefined) wire.geoType = field.geoType
+  if (field.srid !== undefined) wire.srid = field.srid
+  if (field.dimensions !== undefined) wire.dimensions = field.dimensions
+  if (field.check !== undefined) wire.check = field.check
+  if (field.precision !== undefined) wire.precision = field.precision
+  if (field.scale !== undefined) wire.scale = field.scale
+  if (field.sources !== undefined) wire.sources = field.sources
+  if (field.template !== undefined) wire.template = field.template
+  if (field.plugin !== undefined) wire.plugin = field.plugin
+  if (field.fieldType !== undefined) wire.fieldType = field.fieldType
+  if (field.tsType !== undefined) wire.tsType = field.tsType
+
+  return wire
+}
+
+export function scalar(
+  kind: string,
+  extra?: {
+    kernel?: Partial<KernelFieldFacts>
+    db?: Partial<DbFieldAnnotations>
+    platform?: Partial<PlatformFieldAnnotations>
+  },
+): ParsedField {
+  return {
+    kind,
+    kernel: { ...(extra?.kernel ?? {}) },
+    db: { ...DEFAULT_DB_BY_KIND[kind], ...stripUndefined(extra?.db ?? {}) },
+    platform: { ...DEFAULT_PLATFORM_BY_KIND[kind], ...stripUndefined(extra?.platform ?? {}) },
+  }
+}
+
+export function emitField(parsed: ParsedField): FieldAstV2 {
+  if (COMPOSITE_KINDS.has(parsed.kind)) {
+    return { kind: parsed.kind }
+  }
+
+  const db = stripUndefined({
+    ...DEFAULT_DB_BY_KIND[parsed.kind],
+    ...parsed.db,
+  }) as DbFieldAnnotations
+
+  const platform = stripUndefined({
+    ...DEFAULT_PLATFORM_BY_KIND[parsed.kind],
+    ...parsed.platform,
+  }) as PlatformFieldAnnotations
+
+  const wire: FieldAstV2 = { kind: parsed.kind }
+
+  const kernel = parsed.kernel
+  if (kernel.required !== undefined) wire.required = kernel.required
+  if (kernel.primaryKey) wire.primaryKey = true
+  if (kernel.default !== undefined) wire.default = kernel.default
+  if (kernel.localized) wire.localized = true
+  if (kernel.cardinality !== undefined) wire.cardinality = kernel.cardinality
+  if (kernel.target !== undefined) wire.target = kernel.target
+  if (kernel.values !== undefined) wire.values = kernel.values
+  if (kernel.from !== undefined) wire.from = kernel.from
+  if (kernel.sources !== undefined && kernel.sources.length > 0) wire.sources = kernel.sources
+  if (kernel.template !== undefined) wire.template = kernel.template
+  if (kernel.bucket !== undefined) wire.bucket = kernel.bucket
+  if (kernel.accessMode !== undefined) wire.accessMode = kernel.accessMode
+  if (kernel.geoType !== undefined) wire.geoType = kernel.geoType
+  if (kernel.srid !== undefined) wire.srid = kernel.srid
+  if (kernel.dimensions !== undefined) wire.dimensions = kernel.dimensions
+  if (kernel.blocks !== undefined) {
+    wire.blocks = kernel.blocks.map((blockDef) => ({
+      ...blockDef,
+      fields: Object.fromEntries(
+        Object.entries(blockDef.fields).map(([name, nested]) => [
+          name,
+          emitBlockNestedField(nested),
+        ]),
+      ),
+    }))
+  }
+  if (kernel.check !== undefined) wire.check = kernel.check
+  if (kernel.precision !== undefined) wire.precision = kernel.precision
+  if (kernel.scale !== undefined) wire.scale = kernel.scale
+  if (kernel.references !== undefined) wire.references = kernel.references
+  if (kernel.through !== undefined) wire.through = kernel.through
+  if (kernel.onDelete !== undefined) wire.onDelete = kernel.onDelete
+  if (kernel.onUpdate !== undefined) wire.onUpdate = kernel.onUpdate
+  if (kernel.uniqueFk) wire.uniqueFk = true
+  if (kernel.plugin !== undefined) wire.plugin = kernel.plugin
+  if (kernel.fieldType !== undefined) wire.fieldType = kernel.fieldType
+  if (kernel.tsType !== undefined) wire.tsType = kernel.tsType
+  if (parsed.kind === "blocks" && kernel.index !== undefined) wire.index = kernel.index
+
+  const annotations: FieldAnnotations = {}
+  if (hasKeys(db as Record<string, unknown>)) annotations.db = db
+  if (hasKeys(platform as Record<string, unknown>)) annotations.platform = platform
+  if (hasKeys(annotations as Record<string, unknown>)) wire.annotations = annotations
+
+  return wire
+}
+
+export function emitModel(
+  name: string,
+  fields: Record<string, FieldAstV2>,
+  options: Record<string, unknown>,
+  tableName: string,
+  access: Record<string, unknown>,
+): ModelAstV2 {
+  return {
+    name,
+    fields,
+    options,
+    annotations: {
+      db: { tableName, indexes: [] },
+      platform: { access },
+    },
+  }
+}
+
+export function emitSchema(
+  models: ModelAstV2[],
+  extras?: {
+    storageBuckets?: ExtractedSchemaAstV2["storageBuckets"]
+    locales?: string[]
+    defaultLocale?: string
+  },
+): ExtractedSchemaAstV2 {
+  return {
+    astVersion: AST_VERSION,
+    models,
+    ...(extras?.storageBuckets !== undefined &&
+      extras.storageBuckets.length > 0 && { storageBuckets: extras.storageBuckets }),
+    ...(extras?.locales !== undefined && extras.locales.length > 0 && { locales: extras.locales }),
+    ...(extras?.defaultLocale !== undefined && { defaultLocale: extras.defaultLocale }),
+  }
+}

package/src/scripts/postinstall.ts

@@ -1,40 +1,51 @@
 /**
- * Postinstall script — downloads the correct engine binary for the current
- * platform and caches it at ~/.supatype/engine/{version}/supatype-engine[.exe].
+ * Postinstall script — downloads component binaries on first install.
  *
- * Pattern: same as Prisma, esbuild, SWC, Turbo.
+ * Components: supatype-engine, supatype-server, supatype-pg (Postgres), deno.
+ * Binaries are cached in ~/.supatype/cache/{component}/{version}/.
  *
- * The binary is verified via:
- * 1. Minisign signature on checksums.sha256 (proves checksum file is authentic)
- * 2. SHA256 checksum of binary (proves binary matches signed checksum)
+ * Failures are non-fatal: an installation message is printed and the user
+ * can run `supatype update` manually to retry.
  */
 
-import { ENGINE_VERSION } from "../engine-version.js"
-import { detectPlatform } from "../engine/platform.js"
-import { hasCachedBinary } from "../engine/cache.js"
-import { resolveEngine } from "../engine/resolve.js"
+import { download, currentPlatform, fetchAllLatestVersions, type Component } from "../binary-cache.js"
 
-async function main(): Promise<void> {
-  const platform = detectPlatform()
+async function main() {
+  const platform = currentPlatform()
 
-  // Skip if already cached at the right version
-  if (hasCachedBinary(ENGINE_VERSION, platform)) {
-    console.log(`[supatype] Engine v${ENGINE_VERSION} already cached.`)
+  let versions: Record<Component, string>
+  try {
+    console.log("[supatype] Fetching latest component versions...")
+    versions = await fetchAllLatestVersions()
+  } catch (err) {
+    console.error(`[supatype] Failed to fetch latest versions: ${(err as Error).message}`)
+    console.error("[supatype] Run 'supatype update' to download component binaries.")
     return
   }
 
-  console.log(
-    `[supatype] Downloading engine v${ENGINE_VERSION} for ${platform.os}-${platform.arch}...`,
-  )
+  console.log(`[supatype] Downloading component binaries for ${platform.os}/${platform.arch}...`)
 
-  const result = await resolveEngine(ENGINE_VERSION)
-  console.log(`[supatype] Engine installed at ${result.binaryPath}`)
+  const components = Object.entries(versions) as [Component, string][]
+
+  let anyFailed = false
+  for (const [component, version] of components) {
+    try {
+      await download(component, version, platform)
+    } catch (err) {
+      console.error(`[supatype] Failed to download ${component} v${version}: ${(err as Error).message}`)
+      anyFailed = true
+    }
+  }
+
+  if (anyFailed) {
+    console.error("[supatype] Some downloads failed. Run 'supatype update' to retry.")
+  } else {
+    console.log("[supatype] All component binaries downloaded successfully.")
+  }
 }
 
 main().catch((err) => {
-  console.error("[supatype] Engine download failed:", err.message)
-  console.error(
-    "[supatype] You can still use the CLI — the engine will be downloaded on first use.",
-  )
-  // Don't exit(1) — let npm install succeed even if binary download fails.
+  // Non-fatal — postinstall failures should not break npm install.
+  console.error("[supatype] Postinstall failed:", err)
+  process.exit(0)
 })