@supatype/cli 0.1.0-alpha.10

package/src/release-pins.ts

@@ -0,0 +1,31 @@
+/**
+ * Release pins read from files under packages/cli/releases/.
+ * CI (deno-releases workflow) uses the same paths — bump only releases/deno/VERSION.
+ */
+
+import { readFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const CLI_PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..")
+
+function readPinFile(...segments: string[]): string {
+  const path = join(CLI_PACKAGE_ROOT, "releases", ...segments)
+  let raw: string
+  try {
+    raw = readFileSync(path, "utf8")
+  } catch {
+    throw new Error(
+      `Missing release pin file: ${path}\n` +
+        "Expected packages/cli/releases/… — reinstall @supatype/cli or build from the monorepo.",
+    )
+  }
+  const version = raw.trim()
+  if (!/^\d+\.\d+\.\d+/.test(version)) {
+    throw new Error(`Invalid pin in ${path}: expected semver like 2.2.0, got ${JSON.stringify(raw)}`)
+  }
+  return version
+}
+
+/** Pinned Deno runtime for edge functions (also published to CDN under /deno/v{version}/). */
+export const DENO_RELEASE_PIN = readPinFile("deno", "VERSION")

package/src/release-public-key.ts

@@ -0,0 +1,12 @@
+/**
+ * Minisign public key for CDN release verification.
+ * Populated at publish via scripts/embed-release-pubkey.mjs (MINISIGN_PUBLIC_KEY secret),
+ * or overridden at runtime with SUPATYPE_RELEASE_PUBLIC_KEY.
+ */
+export const EMBEDDED_RELEASE_PUBLIC_KEY = "untrusted comment: minisign public key DE133E99689AE71D\nRWQd55pomT4T3t+5FLZZ6+h0DoHrtiuU9RBUHHm9BcFHeGRvW7BXxBCr"
+
+export function releasePublicKey(): string {
+  const fromEnv = process.env["SUPATYPE_RELEASE_PUBLIC_KEY"]?.trim()
+  if (fromEnv) return fromEnv
+  return EMBEDDED_RELEASE_PUBLIC_KEY.trim()
+}

package/src/restore-system-relation-targets.ts

@@ -0,0 +1,45 @@
+/** Restore system relation targets (e.g. supatype:user) in engine-generated admin config. */
+
+function fieldNameToForeignKey(fieldName: string): string {
+  return fieldName
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
+    .replace(/([a-z\d])([A-Z])/g, "$1_$2")
+    .toLowerCase() + "_id"
+}
+
+export function restoreSystemRelationTargets(admin: unknown, ast: unknown): void {
+  if (typeof admin !== "object" || admin === null || typeof ast !== "object" || ast === null) return
+  const astObj = ast as { models?: Array<{ name: string; fields?: Record<string, { kind: string; target?: string }> }> }
+  if (!astObj.models) return
+  const cfg = admin as {
+    models?: Array<{
+      tableName: string
+      fields: Array<{ name: string; widget: string; options?: Record<string, unknown> }>
+    }>
+  }
+  if (!Array.isArray(cfg.models)) return
+
+  const systemTargets = new Map<string, Map<string, string>>()
+  for (const model of astObj.models) {
+    if (!model.fields) continue
+    for (const [fieldName, field] of Object.entries(model.fields)) {
+      if (field.kind === "relation" && field.target?.includes(":")) {
+        const key = model.name.toLowerCase()
+        if (!systemTargets.has(key)) systemTargets.set(key, new Map())
+        systemTargets.get(key)!.set(fieldNameToForeignKey(fieldName), field.target)
+      }
+    }
+  }
+
+  for (const model of cfg.models) {
+    const modelTargets = systemTargets.get(model.tableName)
+    if (!modelTargets) continue
+    for (const field of model.fields) {
+      if (field.widget !== "relation" || !field.options) continue
+      const explicitFk = (field.options["foreignKey"] as string) ?? ""
+      const fk = explicitFk || fieldNameToForeignKey(field.name)
+      const systemTarget = modelTargets.get(fk)
+      if (systemTarget) field.options["target"] = systemTarget
+    }
+  }
+}

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 }),
+  }
+}