@supatype/cli 0.1.0-alpha.10 → 0.1.0-alpha.12

package/src/schema-ast-v2.ts

@@ -293,13 +293,14 @@ export function emitModel(
   options: Record<string, unknown>,
   tableName: string,
   access: Record<string, unknown>,
+  indexes: unknown[] = [],
 ): ModelAstV2 {
   return {
     name,
     fields,
     options,
     annotations: {
-      db: { tableName, indexes: [] },
+      db: { tableName, indexes },
       platform: { access },
     },
   }

package/src/schema-sources.ts

@@ -0,0 +1,248 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  writeFileSync,
+  cpSync,
+} from "node:fs"
+import { join, resolve, relative } from "node:path"
+import { gzipSync, gunzipSync } from "node:zlib"
+import { collectSchemaSourcePaths, type SchemaSourceGraph } from "./type-extractor.js"
+import { loadConfig } from "./config.js"
+import { projectRootFromConfig, schemaPathFromProject } from "./project-config.js"
+
+const MAX_COMPRESSED_BYTES = 2 * 1024 * 1024
+const WARN_COMPRESSED_BYTES = 512 * 1024
+
+export interface SchemaSourcesManifest {
+  version: number
+  format: "tar+gzip"
+  entryPoint: string
+  fileCount: number
+  uncompressedBytes: number
+  compressedBytes: number
+  files: Array<{ path: string; sha256: string; bytes: number }>
+  pushedBy?: string
+}
+
+export interface SchemaSourcesPayload {
+  manifest: SchemaSourcesManifest
+  dataBase64: string
+  gz: Buffer
+}
+
+function padTarField(value: string, len: number): string {
+  return value.slice(0, len).padEnd(len, "\0")
+}
+
+function tarChecksum(header: Buffer): number {
+  let sum = 0
+  for (let i = 0; i < 512; i++) {
+    sum += i >= 148 && i < 156 ? 32 : header[i]!
+  }
+  return sum
+}
+
+function writeTarEntry(name: string, content: Buffer): Buffer {
+  const header = Buffer.alloc(512, 0)
+  const size = content.length
+  header.write(padTarField(name, 100), 0, 100, "ascii")
+  header.write("0000644\0", 100, 8, "ascii")
+  header.write("0000000\0", 108, 8, "ascii")
+  header.write("0000000\0", 116, 8, "ascii")
+  header.write(padTarField(size.toString(8), 11), 124, 12, "ascii")
+  header.write("00000000000\0", 136, 12, "ascii")
+  header.write("        ", 148, 8, "ascii")
+  header.write("ustar\0", 257, 6, "ascii")
+  header.write("00", 263, 2, "ascii")
+  const chk = tarChecksum(header)
+  header.write(chk.toString(8).padStart(6, "0") + "\0 ", 148, 8, "ascii")
+
+  const pad = (512 - (size % 512)) % 512
+  return Buffer.concat([header, content, Buffer.alloc(pad)])
+}
+
+export function packSchemaSources(graph: SchemaSourceGraph): Buffer {
+  const chunks: Buffer[] = []
+  for (const file of graph.files) {
+    const content = readFileSync(file.absolutePath)
+    chunks.push(writeTarEntry(file.relativePath.replace(/\\/g, "/"), content))
+  }
+  chunks.push(Buffer.alloc(1024, 0))
+  return Buffer.concat(chunks)
+}
+
+export function unpackSchemaSources(tar: Buffer, projectRoot: string): Map<string, Buffer> {
+  const root = resolve(projectRoot)
+  const out = new Map<string, Buffer>()
+  let offset = 0
+  while (offset + 512 <= tar.length) {
+    const header = tar.subarray(offset, offset + 512)
+    offset += 512
+    if (header.every((b) => b === 0)) break
+    const name = header.subarray(0, 100).toString("utf8").replace(/\0.*$/, "").trim()
+    if (!name) break
+    const sizeOct = header.subarray(124, 136).toString("utf8").replace(/\0.*$/, "").trim()
+    const size = parseInt(sizeOct, 8) || 0
+    const content = tar.subarray(offset, offset + size)
+    offset += size + ((512 - (size % 512)) % 512)
+    const rel = name.replace(/\\/g, "/")
+    if (rel.startsWith("..") || rel.includes("/../")) {
+      throw new Error(`Invalid tar path: ${name}`)
+    }
+    const dest = resolve(root, rel)
+    if (!dest.startsWith(root)) {
+      throw new Error(`Tar path escapes project root: ${name}`)
+    }
+    out.set(rel, Buffer.from(content))
+  }
+  return out
+}
+
+export function buildSchemaSourcesPayload(
+  cwd: string,
+  pushedBy?: string,
+): SchemaSourcesPayload | null {
+  const config = loadConfig(cwd)
+  const root = projectRootFromConfig(config, cwd)
+  const entry = schemaPathFromProject(config, cwd)
+  const graph = collectSchemaSourcePaths(entry, root)
+  if (graph.files.length === 0) return null
+
+  const tarBuf = packSchemaSources(graph)
+  const gz = gzipSync(tarBuf, { level: 9 })
+
+  if (gz.length > MAX_COMPRESSED_BYTES) {
+    throw new Error(
+      `Schema snapshot too large (${(gz.length / 1024).toFixed(0)} KB compressed, max 2 MB). Split schema modules.`,
+    )
+  }
+  if (gz.length > WARN_COMPRESSED_BYTES) {
+    console.warn(`Warning: large schema snapshot (${(gz.length / 1024).toFixed(0)} KB compressed).`)
+  }
+
+  const manifest: SchemaSourcesManifest = {
+    version: 1,
+    format: "tar+gzip",
+    entryPoint: graph.entryPoint,
+    fileCount: graph.files.length,
+    uncompressedBytes: graph.files.reduce((s, f) => s + f.bytes, 0),
+    compressedBytes: gz.length,
+    files: graph.files.map((f) => ({ path: f.relativePath, sha256: f.sha256, bytes: f.bytes })),
+    ...(pushedBy ? { pushedBy } : {}),
+  }
+
+  return {
+    manifest,
+    dataBase64: gz.toString("base64"),
+    gz,
+  }
+}
+
+export function cacheSchemaSourcesLocally(cwd: string, migrationName: string, gz: Buffer): void {
+  const dir = join(cwd, ".supatype", "schema-snapshots")
+  mkdirSync(dir, { recursive: true })
+  writeFileSync(join(dir, `${migrationName}.tar.gz`), gz)
+}
+
+export function restoreSchemaSourcesFromGz(
+  gz: Buffer,
+  manifest: SchemaSourcesManifest,
+  projectRoot: string,
+  opts?: { backupDir?: string },
+): string[] {
+  const tar = gunzipSync(gz)
+  const files = unpackSchemaSources(tar, projectRoot)
+  const root = resolve(projectRoot)
+  const restored: string[] = []
+
+  if (opts?.backupDir) {
+    mkdirSync(opts.backupDir, { recursive: true })
+    for (const path of manifest.files) {
+      const abs = join(root, path.path)
+      if (existsSync(abs)) {
+        const dest = join(opts.backupDir, path.path)
+        mkdirSync(join(dest, ".."), { recursive: true })
+        cpSync(abs, dest)
+      }
+    }
+  }
+
+  for (const [rel, content] of files) {
+    const abs = join(root, rel)
+    mkdirSync(join(abs, ".."), { recursive: true })
+    writeFileSync(abs, content)
+    restored.push(rel)
+  }
+
+  return restored
+}
+
+export function findOrphanSchemaFiles(
+  projectRoot: string,
+  entryPoint: string,
+  manifestPaths: Set<string>,
+): string[] {
+  const entry = resolve(projectRoot, entryPoint)
+  const graph = collectSchemaSourcePaths(entry, projectRoot)
+  const orphans: string[] = []
+  const schemaDir = join(projectRoot, graph.entryPoint.split("/").slice(0, -1).join("/") || ".")
+  if (!existsSync(schemaDir)) return orphans
+
+  const walk = (dir: string): void => {
+    for (const ent of readdirSync(dir, { withFileTypes: true })) {
+      const abs = join(dir, ent.name)
+      if (ent.isDirectory()) {
+        walk(abs)
+        continue
+      }
+      if (!/\.(ts|tsx)$/.test(ent.name)) continue
+      const rel = relative(projectRoot, abs).replace(/\\/g, "/")
+      if (!manifestPaths.has(rel) && !graph.files.some((f) => f.relativePath === rel)) {
+        orphans.push(rel)
+      }
+    }
+  }
+  walk(schemaDir)
+  return orphans
+}
+
+export function resolvePushedBy(): string {
+  return (
+    process.env["SUPATYPE_PUSHED_BY"] ??
+    process.env["USER"] ??
+    process.env["USERNAME"] ??
+    "local"
+  )
+}
+
+export interface SchemaSourcePushArtifacts {
+  gzPath: string
+  manifestPath: string
+  /** Paths inside the Docker /project bind mount. */
+  dockerGzPath: string
+  dockerManifestPath: string
+  payload: SchemaSourcesPayload
+}
+
+/** Write schema source blob + manifest under `.supatype/` for engine push (CLI + dev watch). */
+export function writeSchemaSourcePushArtifacts(cwd: string): SchemaSourcePushArtifacts | null {
+  const payload = buildSchemaSourcesPayload(cwd, resolvePushedBy())
+  if (!payload) return null
+
+  const dir = join(cwd, ".supatype")
+  mkdirSync(dir, { recursive: true })
+  const gzPath = join(dir, "schema-sources-push.gz")
+  const manifestPath = join(dir, "schema-sources-manifest.json")
+  writeFileSync(gzPath, payload.gz)
+  writeFileSync(manifestPath, JSON.stringify(payload.manifest))
+
+  return {
+    gzPath,
+    manifestPath,
+    dockerGzPath: "/project/.supatype/schema-sources-push.gz",
+    dockerManifestPath: "/project/.supatype/schema-sources-manifest.json",
+    payload,
+  }
+}

package/src/self-host-compose.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs"
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
 import { dirname, join, relative, resolve } from "node:path"
 import { spawnSync } from "node:child_process"
 import { preferredFunctionsPathFromProject, type SupatypeProjectConfig } from "./project-config.js"
@@ -12,6 +12,16 @@ export const COMPOSE_PINNED_IMAGE_ENV_KEYS = [
   "SUPATYPE_POSTGRES_IMAGE",
 ] as const
 
+/** Compose image env vars that may be overridden manually in `.env`. */
+export const COMPOSE_IMAGE_ENV_KEYS = [
+  ...COMPOSE_PINNED_IMAGE_ENV_KEYS,
+  "SUPATYPE_CONTROL_PLANE_IMAGE",
+  "SUPATYPE_AUTH_IMAGE",
+  "SUPATYPE_STUDIO_IMAGE",
+  "SUPATYPE_STORAGE_IMAGE",
+  "SUPATYPE_FUNCTIONS_WORKER_IMAGE",
+] as const
+
 type DockerPinComponent = "engine" | "server" | "postgres"
 
 /** Map a config version pin to a Docker Hub image reference. */
@@ -57,6 +67,52 @@ export function composeDockerImageEnv(config: SupatypeProjectConfig): Record<str
   return env
 }
 
+/** True when a Docker image tag is a semver/latest ref we expect `docker pull` to resolve. */
+export function isRegistryPullableImageRef(ref: string): boolean {
+  const trimmed = ref.trim()
+  if (!trimmed) return true
+  const tag = trimmed.includes(":") ? trimmed.slice(trimmed.lastIndexOf(":") + 1) : "latest"
+  if (tag === "latest") return true
+  if (/^v?\d+\.\d+/.test(tag)) return true
+  if (/^\d+-latest$/.test(tag)) return true
+  return false
+}
+
+export function hasLocalVersionPins(config: SupatypeProjectConfig): boolean {
+  const versions = config.versions
+  if (!versions) return false
+  return (
+    versions.engine === VERSION_PIN_LOCAL ||
+    versions.server === VERSION_PIN_LOCAL ||
+    versions.postgres === VERSION_PIN_LOCAL ||
+    versions.deno === VERSION_PIN_LOCAL
+  )
+}
+
+function readComposeImageEnvValues(cwd: string): string[] {
+  const envPath = resolve(cwd, ".env")
+  if (!existsSync(envPath)) return []
+  const text = readFileSync(envPath, "utf8")
+  const values: string[] = []
+  for (const key of COMPOSE_IMAGE_ENV_KEYS) {
+    const match = text.match(new RegExp(`^${key}=(.+)$`, "m"))
+    if (match?.[1]) values.push(match[1].trim())
+  }
+  return values
+}
+
+/**
+ * Use `docker compose pull --ignore-pull-failures` only when the project may
+ * reference local-only images (config `versions: local` or custom `.env` tags).
+ */
+export function composePullNeedsIgnoreFailures(
+  config: SupatypeProjectConfig,
+  cwd: string = process.cwd(),
+): boolean {
+  if (hasLocalVersionPins(config)) return true
+  return readComposeImageEnvValues(cwd).some((ref) => !isRegistryPullableImageRef(ref))
+}
+
 /**
  * Schema-engine image for a one-off `docker compose run` when pushing schema.
  * Uses config pin when set; otherwise CDN engine semver (Docker Hub `:latest` can lag).
@@ -174,6 +230,8 @@ export function renderSelfHostCompose(
   const devLocal = options?.devLocal === true
   const studioHostDev = devLocal && hasStudioOverride(config)
   const appEnv = serverAppEnvForCompose(config, devLocal)
+  const staticDir = staticDirForCompose(config) ?? "./dist"
+  const composeProject = composeProjectName(config.project.name)
   const studioService = studioServiceBlock()
   const studioBlock = studioHostDev
     ? ""
@@ -186,9 +244,11 @@ ${studioService}
       - "3002"
 `
   const kongDependsOn = studioHostDev
-    ? `      - server`
+    ? `      - server
+      - control-plane`
     : `      - server
-      - studio`
+      - studio
+      - control-plane`
   const publishDbToHost = !devLocal || hasEngineOverride(config)
   const dbPorts = publishDbToHost
     ? devLocal
@@ -280,6 +340,27 @@ ${dbPorts}    volumes:
       db:
         condition: service_healthy
 
+  control-plane:
+    image: \${SUPATYPE_CONTROL_PLANE_IMAGE:-supatype/control-plane:latest}
+    expose:
+      - "8080"
+    volumes:
+      - ${projectMount}:/project
+      - /var/run/docker.sock:/var/run/docker.sock
+    environment:
+      PORT: "8080"
+      SUPATYPE_PROJECT_REF: ${JSON.stringify(config.project.name)}
+      SUPATYPE_PROJECT_ROOT: /project
+      DATABASE_URL: "postgresql://\${POSTGRES_USER:-supatype_admin}:\${POSTGRES_PASSWORD:-postgres}@db:5432/\${POSTGRES_DB:-supatype}"
+      SUPATYPE_FUNCTIONS_ROOT: /project/functions
+      SUPATYPE_STATIC_ROOT: /project/${staticDir.replace(/^\.\//, "")}
+      SUPATYPE_DEPLOYMENTS_DIR: /project/.supatype/deployments
+      COMPOSE_PROJECT_NAME: ${composeProject}
+      SUPATYPE_ENGINE_BIN: supatype-engine
+    depends_on:
+      db:
+        condition: service_healthy
+
   server:
     image: \${SUPATYPE_SERVER_IMAGE:-\${SUPATYPE_AUTH_IMAGE:-supatype/server:latest}}
 ${serverPorts}    volumes:
@@ -299,6 +380,7 @@ ${serverPorts}    volumes:
       SUPATYPE_SQL_DATABASE_URL: "postgresql://\${POSTGRES_USER:-supatype_admin}:\${POSTGRES_PASSWORD:-postgres}@db:5432/\${POSTGRES_DB:-supatype}"
       SUPATYPE_DENO_FUNCTIONS_DIR: /project/functions
       SUPATYPE_FUNCTIONS_WORKER_URL: http://functions-worker:8001
+      SUPATYPE_CONTROL_PLANE_URL: http://control-plane:8080
 ${appEnv}
       GOTRUE_API_HOST: 0.0.0.0
       GOTRUE_API_PORT: 9999
@@ -324,6 +406,8 @@ ${devLocal ? "      STUDIO_OPEN_DEV: \"1\"\n" : ""}
         condition: service_started
       functions-worker:
         condition: service_started
+      control-plane:
+        condition: service_started
 
   minio:
     image: minio/minio:RELEASE.2024-11-07T00-52-20Z

package/src/storage-provision.ts

@@ -6,6 +6,10 @@
  * Buckets already registered return 409 Conflict, which is treated as success.
  */
 
+import type { ExtractedSchemaAstV2 } from "./schema-ast-v2.js"
+
+export type { ExtractedStorageBucketAst as SchemaStorageBucketAst } from "./schema-ast-v2.js"
+
 export interface BucketSpec {
   id: string
   public: boolean
@@ -15,6 +19,29 @@ export interface BucketSpec {
   s3_bucket_policy?: string | null
 }
 
+export function bucketSpecsFromAst(ast: Pick<ExtractedSchemaAstV2, "storageBuckets">): BucketSpec[] {
+  return (ast.storageBuckets ?? []).map((b) => ({
+    id: b.id,
+    public: b.public,
+    ...(b.accessMode !== undefined && { access_mode: b.accessMode }),
+    ...(b.allowedMimeTypes != null && { allowed_mime_types: b.allowedMimeTypes }),
+    ...(b.fileSizeLimit != null && { file_size_limit: b.fileSizeLimit }),
+    ...(b.s3BucketPolicy != null &&
+      b.s3BucketPolicy !== "" && { s3_bucket_policy: b.s3BucketPolicy }),
+  }))
+}
+
+export async function provisionBucketsFromAst(
+  ast: Pick<ExtractedSchemaAstV2, "storageBuckets">,
+  storageApiUrl: string,
+  serviceRoleKey: string,
+): Promise<void> {
+  const buckets = bucketSpecsFromAst(ast)
+  if (buckets.length === 0) return
+  console.log("[supatype] Provisioning storage buckets...")
+  await provisionBuckets(storageApiUrl, serviceRoleKey, buckets)
+}
+
 /**
  * Ensure all declared buckets exist in the storage server.
  *
@@ -48,11 +75,16 @@ export async function provisionBuckets(
     const res = await fetch(`${base}/bucket`, { method: "POST", headers, body })
       .catch(() => null)
 
-    if (res === null) continue // server not reachable — skip silently
+    if (res === null) {
+      console.warn(`[storage] Storage API unreachable — skipped bucket "${bucket.id}"`)
+      continue
+    }
     if (res.status === 409) continue // already exists — fine
     if (!res.ok) {
       const msg = await res.text().catch(() => res.statusText)
       console.warn(`[storage] Failed to provision bucket "${bucket.id}": ${msg}`)
+      continue
     }
+    console.log(`[supatype] Storage bucket "${bucket.id}" ready.`)
   }
 }

package/src/target-client.ts

@@ -0,0 +1,40 @@
+export interface TargetFetchOptions {
+  method: string
+  path: string
+  body?: unknown
+  token: string
+  orgId?: string | undefined
+  environment?: string | undefined
+}
+
+export async function targetFetch<T>(
+  baseUrl: string,
+  apiPrefix: "/api/v1" | "/platform/v1",
+  opts: TargetFetchOptions,
+): Promise<T> {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${opts.token}`,
+  }
+  if (opts.orgId) headers["X-Org-Id"] = opts.orgId
+  if (opts.environment) headers["X-Supatype-Environment"] = opts.environment
+
+  const url = `${baseUrl.replace(/\/$/, "")}${apiPrefix}${opts.path}`
+  const res = await fetch(url, {
+    method: opts.method,
+    headers,
+    ...(opts.body !== undefined ? { body: JSON.stringify(opts.body) } : {}),
+  })
+
+  const json = (await res.json().catch(() => ({}))) as {
+    data?: T
+    error?: string
+    message?: string
+  }
+
+  if (!res.ok) {
+    throw new Error(json.message ?? json.error ?? `API error: ${res.status} ${url}`)
+  }
+
+  return (json.data !== undefined ? json.data : json) as T
+}

package/src/type-extractor.ts

@@ -1,5 +1,6 @@
-import { existsSync, readFileSync } from "node:fs"
-import { dirname, isAbsolute, resolve } from "node:path"
+import { existsSync, readFileSync, realpathSync } from "node:fs"
+import { createHash } from "node:crypto"
+import { dirname, isAbsolute, relative, resolve } from "node:path"
 import ts from "typescript"
 import {
   applyImportRename,
@@ -103,7 +104,7 @@ export function extractSchemaAstFromTypes(
         )
       }
 
-      const { tableName, access, options } = parseModelMeta(
+      const { tableName, access, options, indexes } = parseModelMeta(
         metaArg,
         sourceFile,
         stmt.name.text,
@@ -112,7 +113,7 @@ export function extractSchemaAstFromTypes(
       )
 
       models.push(
-        emitModel(stmt.name.text, fields, options, tableName, access),
+        emitModel(stmt.name.text, fields, options, tableName, access, indexes),
       )
     }
   }
@@ -143,9 +144,51 @@ export function extractSchemaAstFromTypes(
   })
 }
 
-function loadSchemaSourceFiles(entryPath: string): ts.SourceFile[] {
+export interface SchemaSourceFile {
+  relativePath: string
+  absolutePath: string
+  sha256: string
+  bytes: number
+}
+
+export interface SchemaSourceGraph {
+  entryPoint: string
+  files: SchemaSourceFile[]
+}
+
+export function collectSchemaSourcePaths(entryAbsPath: string, projectRoot: string): SchemaSourceGraph {
+  const root = resolve(projectRoot)
+  const entryReal = realpathSync(entryAbsPath)
+  const entryPoint = relative(root, entryReal).replace(/\\/g, "/")
+  if (entryPoint.startsWith("..")) {
+    throw new Error(`Schema entry must be under project root: ${entryAbsPath}`)
+  }
+
+  const absolutePaths = walkSchemaSourceAbsPaths(entryReal)
+  const files: SchemaSourceFile[] = []
+
+  for (const abs of absolutePaths) {
+    const real = realpathSync(abs)
+    const rel = relative(root, real).replace(/\\/g, "/")
+    if (rel.startsWith("..")) {
+      throw new Error(`Schema source escapes project root: ${abs}`)
+    }
+    const content = readFileSync(real)
+    files.push({
+      relativePath: rel,
+      absolutePath: real,
+      sha256: createHash("sha256").update(content).digest("hex"),
+      bytes: content.length,
+    })
+  }
+
+  files.sort((a, b) => a.relativePath.localeCompare(b.relativePath))
+  return { entryPoint, files }
+}
+
+function walkSchemaSourceAbsPaths(entryPath: string): string[] {
   const visited = new Set<string>()
-  const sourceFiles: ts.SourceFile[] = []
+  const paths: string[] = []
   const queue: string[] = [entryPath]
 
   while (queue.length > 0) {
@@ -153,12 +196,11 @@ function loadSchemaSourceFiles(entryPath: string): ts.SourceFile[] {
     if (!currentPath) continue
     if (visited.has(currentPath)) continue
     visited.add(currentPath)
-
     if (!existsSync(currentPath)) continue
+    paths.push(currentPath)
+
     const sourceText = readFileSync(currentPath, "utf8")
     const sourceFile = ts.createSourceFile(currentPath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
-    sourceFiles.push(sourceFile)
-
     const baseDir = dirname(currentPath)
     for (const stmt of sourceFile.statements) {
       let specifier: string | undefined
@@ -178,7 +220,14 @@ function loadSchemaSourceFiles(entryPath: string): ts.SourceFile[] {
     }
   }
 
-  return sourceFiles
+  return paths
+}
+
+function loadSchemaSourceFiles(entryPath: string): ts.SourceFile[] {
+  return walkSchemaSourceAbsPaths(entryPath).map((abs) => {
+    const sourceText = readFileSync(abs, "utf8")
+    return ts.createSourceFile(abs, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+  })
 }
 
 function resolveTypeModulePath(fromDir: string, specifier: string): string | null {
@@ -1372,7 +1421,12 @@ function parseModelMeta(
   modelName: string,
   fieldsArg: ts.TypeNode,
   fields: Record<string, FieldAstV2>,
-): { tableName: string; access: Record<string, unknown>; options: Record<string, unknown> } {
+): {
+  tableName: string
+  access: Record<string, unknown>
+  options: Record<string, unknown>
+  indexes: unknown[]
+} {
   const literal = parseMetaLiteral(metaArg, sourceFile)
   const singleton = literal.singleton === true
   const tableName =
@@ -1397,7 +1451,66 @@ function parseModelMeta(
     tableName,
     access: parseModelAccess(metaArg, sourceFile),
     options,
+    indexes: parseModelIndexes(metaArg, sourceFile, fields),
+  }
+}
+
+function parseModelIndexes(
+  metaArg: ts.TypeNode | undefined,
+  sourceFile: ts.SourceFile,
+  fields: Record<string, FieldAstV2>,
+): unknown[] {
+  if (!metaArg || !ts.isTypeLiteralNode(metaArg)) return []
+
+  const indexesProp = metaArg.members.find(
+    (member) => ts.isPropertySignature(member) && getPropertyName(member.name) === "indexes",
+  )
+  if (
+    !indexesProp ||
+    !ts.isPropertySignature(indexesProp) ||
+    !indexesProp.type ||
+    !ts.isTupleTypeNode(indexesProp.type)
+  ) {
+    return []
+  }
+
+  const indexes: unknown[] = []
+  for (const element of indexesProp.type.elements) {
+    if (!ts.isTypeLiteralNode(element)) continue
+    const indexDef: Record<string, unknown> = { using: "btree" }
+    for (const member of element.members) {
+      if (!ts.isPropertySignature(member) || !member.type) continue
+      const key = getPropertyName(member.name)
+      if (!key) continue
+      if (key === "name" && ts.isLiteralTypeNode(member.type) && ts.isStringLiteral(member.type.literal)) {
+        indexDef.name = member.type.literal.text
+      } else if (key === "unique" && isBooleanLiteralType(member.type, true)) {
+        indexDef.unique = true
+      } else if (key === "fields" && ts.isTupleTypeNode(member.type)) {
+        indexDef.fields = member.type.elements
+          .map((fieldNode) => {
+            if (!ts.isLiteralTypeNode(fieldNode) || !ts.isStringLiteral(fieldNode.literal)) return null
+            return resolveIndexFieldName(fieldNode.literal.text, fields)
+          })
+          .filter((field): field is string => field !== null)
+      }
+    }
+    if (Array.isArray(indexDef.fields) && indexDef.fields.length > 0) {
+      indexes.push(indexDef)
+    }
+  }
+  return indexes
+}
+
+function resolveIndexFieldName(fieldName: string, fields: Record<string, FieldAstV2>): string | null {
+  if (fields[fieldName] !== undefined) {
+    const field = fields[fieldName]
+    if (field.kind === "relation" && field.annotations?.db?.foreignKey) {
+      return field.annotations.db.foreignKey as string
+    }
+    return fieldName
   }
+  return fieldName
 }
 
 function parseModelAccess(metaArg: ts.TypeNode | undefined, sourceFile: ts.SourceFile): Record<string, unknown> {