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

package/tests/type-extractor.test.ts

@@ -2,10 +2,19 @@ import { mkdtempSync, rmSync, writeFileSync } from "node:fs"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
 import { afterEach, describe, expect, it } from "vitest"
+import type { ModelAstV2 } from "../src/schema-ast-v2.js"
 import { extractSchemaAstFromTypes } from "../src/type-extractor.js"
 
 const dirs: string[] = []
 
+function tableName(model: ModelAstV2 | undefined): string | undefined {
+  return model?.annotations.db.tableName
+}
+
+function modelAccess(model: ModelAstV2 | undefined): Record<string, unknown> {
+  return model?.annotations.platform.access ?? {}
+}
+
 afterEach(() => {
   for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true })
 })
@@ -42,27 +51,32 @@ export type Comment = Model<{
 
     const ast = extractSchemaAstFromTypes(schemaPath, dir)
     expect(ast).not.toBeNull()
+    expect(ast?.astVersion).toBe(2)
     expect(ast?.models).toHaveLength(2)
     const post = ast?.models.find((m) => m.name === "Post")
     const comment = ast?.models.find((m) => m.name === "Comment")
-    expect(post?.tableName).toBe("post")
+    expect(tableName(post)).toBe("post")
     expect(comment?.fields["post"]).toMatchObject({
       kind: "relation",
       cardinality: "belongsTo",
       target: "Post",
-      foreignKey: "post_id",
+      annotations: { db: { foreignKey: "post_id" } },
     })
-    expect(post?.fields["id"]).toMatchObject({ kind: "uuid", pgType: "UUID" })
     expect(post?.fields["id"]).toMatchObject({
+      kind: "uuid",
+      annotations: { db: { pgType: "UUID", unique: true } },
       primaryKey: true,
-      unique: true,
       required: true,
       default: { kind: "genRandomUuid" },
     })
-    expect(post?.fields["slug"]).toMatchObject({ kind: "slug", unique: true, from: "title" })
-    expect(post?.access["read"]).toEqual({ type: "public" })
-    expect(post?.access["update"]).toEqual({ type: "owner", field: "author_id" })
-    expect(post?.access["delete"]).toEqual({ type: "owner", field: "author_id" })
+    expect(post?.fields["slug"]).toMatchObject({
+      kind: "slug",
+      from: "title",
+      annotations: { db: { unique: true } },
+    })
+    expect(modelAccess(post)["read"]).toEqual({ type: "public" })
+    expect(modelAccess(post)["update"]).toEqual({ type: "owner", field: "author_id" })
+    expect(modelAccess(post)["delete"]).toEqual({ type: "owner", field: "author_id" })
   })
 
   it("emits DEFAULT now for created_at / updated_at timestamp columns", () => {
@@ -83,12 +97,12 @@ export type Entry = Model<{ id: UUID; created_at: Timestamp; updated_at: Timesta
     const entry = ast?.models.find((m) => m.name === "Entry")
     expect(entry?.fields["created_at"]).toMatchObject({
       kind: "datetime",
-      serverGenerated: true,
+      annotations: { db: { serverGenerated: true, pgType: "TIMESTAMP WITH TIME ZONE" } },
       default: { kind: "now" },
     })
     expect(entry?.fields["updated_at"]).toMatchObject({
       kind: "datetime",
-      serverGenerated: true,
+      annotations: { db: { serverGenerated: true, pgType: "TIMESTAMP WITH TIME ZONE" } },
       default: { kind: "now" },
     })
   })
@@ -113,8 +127,8 @@ export type User = Model<{
 
     const ast = extractSchemaAstFromTypes(schemaPath, dir)
     const user = ast?.models.find((m) => m.name === "User")
-    expect(user?.access["update"]).toEqual({ type: "owner", field: "id" })
-    expect(user?.access["delete"]).toEqual({ type: "owner", field: "id" })
+    expect(modelAccess(user)["update"]).toEqual({ type: "owner", field: "id" })
+    expect(modelAccess(user)["delete"]).toEqual({ type: "owner", field: "id" })
   })
 
   it("maps SupatypeAuthUser relations and OwnerFrom relation keys", () => {
@@ -142,10 +156,10 @@ export type Post = Model<{
       kind: "relation",
       cardinality: "belongsTo",
       target: "supatype:user",
-      foreignKey: "auth_user_id",
+      annotations: { db: { foreignKey: "auth_user_id" } },
     })
-    expect(post?.access["update"]).toEqual({ type: "owner", field: "auth_user_id" })
-    expect(post?.access["delete"]).toEqual({ type: "owner", field: "auth_user_id" })
+    expect(modelAccess(post)["update"]).toEqual({ type: "owner", field: "authUser" })
+    expect(modelAccess(post)["delete"]).toEqual({ type: "owner", field: "authUser" })
   })
 
   it("unwraps Default<> so boolean fields stay boolean in the AST", () => {
@@ -165,7 +179,85 @@ export type Flags = Model<{
       "utf8",
     )
     const ast = extractSchemaAstFromTypes(schemaPath, dir)
-    expect(ast?.models[0]?.fields["isActive"]).toMatchObject({ kind: "boolean", pgType: "BOOLEAN" })
+    expect(ast?.models[0]?.fields["isActive"]).toMatchObject({
+      kind: "boolean",
+      annotations: { db: { pgType: "BOOLEAN" } },
+      default: { kind: "value", value: true },
+    })
+  })
+
+  it("extracts Default<> literal values for scalars and RichText plain-string defaults", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-defaults-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID, Default, Int, RichText } from "@supatype/types"
+
+export type Product = Model<{
+  id: UUID
+  stock: Default<Int, 0>
+  blurb: Default<RichText, "Welcome to our shop.">
+}>
+`,
+      "utf8",
+    )
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    expect(ast?.models[0]?.fields["stock"]).toMatchObject({
+      kind: "integer",
+      default: { kind: "value", value: 0 },
+    })
+    expect(ast?.models[0]?.fields["blurb"]).toMatchObject({
+      kind: "richText",
+      annotations: { db: { pgType: "JSONB" }, platform: { editor: "rich" } },
+      default: { kind: "value", value: "Welcome to our shop." },
+    })
+  })
+
+  it("extracts RichText<\"…\"> inline default (equivalent to Default<RichText, \"…\">)", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-richtext-inline-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID, RichText } from "@supatype/types"
+
+export type Page = Model<{
+  id: UUID
+  intro: RichText<"Welcome to Elmside.">
+}>
+`,
+      "utf8",
+    )
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    expect(ast?.models[0]?.fields["intro"]).toMatchObject({
+      kind: "richText",
+      annotations: { db: { pgType: "JSONB" }, platform: { editor: "rich" } },
+      default: { kind: "value", value: "Welcome to Elmside." },
+    })
+  })
+
+  it("errors when RichText inline default and Default<> are both set", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-richtext-double-default-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID, Default, RichText } from "@supatype/types"
+
+export type Page = Model<{
+  id: UUID
+  intro: Default<RichText<"a">, "b">
+}>
+`,
+      "utf8",
+    )
+    expect(() => extractSchemaAstFromTypes(schemaPath, dir)).toThrow(
+      /either Default<…> or an inline type default/,
+    )
   })
 
   it("extracts Bucket<> config into storageBuckets and field accessMode", () => {
@@ -279,9 +371,15 @@ export type Comment = Model<{
     )
     const ast = extractSchemaAstFromTypes(schemaPath, dir)
     const comment = ast?.models.find((m) => m.name === "Comment")
-    expect(comment?.fields["author"]).toMatchObject({ foreignKey: "author_id" })
-    expect(comment?.fields["userId"]).toMatchObject({ foreignKey: "user_id" })
-    expect(comment?.fields["customerID"]).toMatchObject({ foreignKey: "customer_id" })
+    expect(comment?.fields["author"]).toMatchObject({
+      annotations: { db: { foreignKey: "author_id" } },
+    })
+    expect(comment?.fields["userId"]).toMatchObject({
+      annotations: { db: { foreignKey: "user_id" } },
+    })
+    expect(comment?.fields["customerID"]).toMatchObject({
+      annotations: { db: { foreignKey: "customer_id" } },
+    })
   })
 
   it("extracts EditorReadOnly wrapper as readOnly field metadata", () => {
@@ -305,8 +403,14 @@ export type Doc = Model<{
     )
     const ast = extractSchemaAstFromTypes(schemaPath, dir)
     const doc = ast?.models.find((m) => m.name === "Doc")
-    expect(doc?.fields["title"]).toMatchObject({ kind: "text", readOnly: true })
-    expect(doc?.fields["owner"]).toMatchObject({ kind: "relation", readOnly: true })
+    expect(doc?.fields["title"]).toMatchObject({
+      kind: "text",
+      annotations: { platform: { readOnly: true } },
+    })
+    expect(doc?.fields["owner"]).toMatchObject({
+      kind: "relation",
+      annotations: { platform: { readOnly: true } },
+    })
   })
 
   it("extracts Computed wrapper as readOnly + serverGenerated metadata", () => {
@@ -330,8 +434,7 @@ export type Doc = Model<{
     expect(doc?.fields["summary"]).toMatchObject({
       kind: "text",
       required: false,
-      readOnly: true,
-      serverGenerated: true,
+      annotations: { db: { serverGenerated: true }, platform: { readOnly: true } },
     })
   })
 
@@ -398,4 +501,485 @@ export type Note = Model<{
     })
     expect(new Set(summary?.sources ?? [])).toEqual(new Set(["author", "published_at", "description"]))
   })
+
+  it("extracts singleton: true with default _global_ table name", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-singleton-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID, Public, Role, Timestamp } from "@supatype/types"
+
+export type SiteSettings = Model<{
+  id: UUID
+  site_name: string
+  created_at: Timestamp
+  updated_at: Timestamp
+}, {
+  singleton: true
+  access: { read: Public; update: Role<"supatype_admin"> }
+}>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    const settings = ast?.models.find((m) => m.name === "SiteSettings")
+    expect(tableName(settings)).toBe("_global_site_settings")
+    expect(settings?.options).toMatchObject({ singleton: true, timestamps: true })
+  })
+
+  it("respects tableName override on singleton models", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-singleton-table-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID, Public } from "@supatype/types"
+
+export type Config = Model<{
+  id: UUID
+}, {
+  singleton: true
+  tableName: "config"
+  access: { read: Public }
+}>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    const config = ast?.models.find((m) => m.name === "Config")
+    expect(tableName(config)).toBe("config")
+    expect(config?.options.singleton).toBe(true)
+  })
+
+  it("infers timestamps from WithTimestamps wrapper", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-timestamps-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID, WithTimestamps, Public } from "@supatype/types"
+
+export type Post = Model<WithTimestamps<{
+  id: UUID
+  title: string
+}>, {
+  access: { read: Public }
+}>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    const post = ast?.models.find((m) => m.name === "Post")
+    expect(post?.options.timestamps).toBe(true)
+    expect(post?.options.singleton).toBeUndefined()
+  })
+
+  it("extracts LocaleConfig into schema AST locales", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-types-locale-config-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { LocaleConfig, Model, UUID } from "@supatype/types"
+
+export type localeConfig = LocaleConfig<["en", "de"], "en">
+
+export type Page = Model<{ id: UUID; title: string }>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    expect(ast?.locales).toEqual(["en", "de"])
+    expect(ast?.defaultLocale).toBe("en")
+  })
+
+  it("marks Localized fields as JSONB with localized:true", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-types-localized-field-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Localized, Model, Optional, RichText, UUID } from "@supatype/types"
+
+export type Page = Model<{
+  id: UUID
+  title: Localized<string>
+  body: Localized<RichText>
+  subtitle: Optional<Localized<string>>
+}>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    const page = ast?.models.find((m) => m.name === "Page")
+    expect(page?.fields["title"]).toMatchObject({
+      kind: "text",
+      annotations: { db: { pgType: "JSONB" } },
+      localized: true,
+      required: true,
+    })
+    expect(page?.fields["body"]).toMatchObject({
+      kind: "richText",
+      annotations: { db: { pgType: "JSONB" }, platform: { editor: "rich" } },
+      localized: true,
+    })
+    expect(page?.fields["subtitle"]).toMatchObject({
+      kind: "text",
+      annotations: { db: { pgType: "JSONB" } },
+      localized: true,
+      required: false,
+    })
+  })
+
+  it("extracts LocalizedModel with auto-localized copy fields", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-types-localized-model-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type {
+  LocalizedModel,
+  UUID,
+  ImageAsset,
+  NotLocalized,
+  Blocks,
+  Block,
+  Bucket,
+} from "@supatype/types"
+
+export type marketing = Bucket<"marketing", { accessMode: "public" }>
+export type RuleBlock = Block<"rule", { text: string }>
+
+export type Homepage = LocalizedModel<{
+  id: UUID
+  hero_title: string
+  map_url: NotLocalized<string>
+  og_image: ImageAsset<marketing, { localized: true }>
+  hero_slides: Blocks<RuleBlock>
+}>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    const homepage = ast?.models.find((m) => m.name === "Homepage")
+    expect(homepage?.fields["hero_title"]).toMatchObject({
+      kind: "text",
+      localized: true,
+      annotations: { db: { pgType: "JSONB" } },
+    })
+    expect(homepage?.fields["map_url"]?.localized).toBeUndefined()
+    expect(homepage?.fields["og_image"]).toMatchObject({
+      kind: "image",
+      localized: true,
+    })
+    const slides = homepage?.fields["hero_slides"] as { blocks?: { fields: Record<string, unknown> }[] }
+    expect(slides?.blocks?.[0]?.fields["text"]).toMatchObject({
+      kind: "text",
+      localized: true,
+      pgType: "JSONB",
+    })
+  })
+
+  it("marks Localized<Blocks<...>> as localized column", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-types-localized-blocks-col-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Localized, Model, UUID, Blocks, Block } from "@supatype/types"
+
+export type Slide = Block<"slide", { image_path: string }>
+
+export type Page = Model<{
+  id: UUID
+  slides: Localized<Blocks<Slide>>
+}>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    const page = ast?.models.find((m) => m.name === "Page")
+    expect(page?.fields["slides"]).toMatchObject({
+      kind: "blocks",
+      localized: true,
+      annotations: { db: { pgType: "JSONB" } },
+    })
+  })
+
+  it("resolves type alias Nullable<T> = Optional<T>", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-alias-nullable-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID, Email, Optional } from "@supatype/types"
+
+type Nullable<T> = Optional<T>
+
+export type User = Model<{
+  id: UUID
+  email: Nullable<Email>
+}>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    const user = ast?.models.find((m) => m.name === "User")
+    expect(user?.fields["email"]).toMatchObject({
+      kind: "email",
+      required: false,
+    })
+  })
+
+  it("resolves multi-hop type aliases", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-alias-multihop-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID, Email, Optional } from "@supatype/types"
+
+type Nullable<T> = Optional<T>
+type A = Nullable<Email>
+type B = A
+
+export type User = Model<{ id: UUID; email: B }>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    const user = ast?.models.find((m) => m.name === "User")
+    expect(user?.fields["email"]).toMatchObject({
+      kind: "email",
+      required: false,
+    })
+  })
+
+  it("resolves enum string-union type aliases", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-alias-enum-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID } from "@supatype/types"
+
+type Status = "draft" | "published" | "archived"
+
+export type Post = Model<{ id: UUID; status: Status }>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    expect(ast?.models[0]?.fields["status"]).toMatchObject({
+      kind: "enum",
+      values: ["draft", "published", "archived"],
+    })
+  })
+
+  it("resolves import renames of @supatype/types primitives", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-import-rename-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID, Email, Optional as Maybe } from "@supatype/types"
+
+export type User = Model<{ id: UUID; email: Maybe<Email> }>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    const user = ast?.models.find((m) => m.name === "User")
+    expect(user?.fields["email"]).toMatchObject({
+      kind: "email",
+      required: false,
+    })
+  })
+
+  it("resolves cross-file type aliases via local import", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-cross-file-alias-"))
+    dirs.push(dir)
+    writeFileSync(
+      join(dir, "field-types.ts"),
+      `
+import type { Optional } from "@supatype/types"
+
+export type Nullable<T> = Optional<T>
+`,
+      "utf8",
+    )
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID, Email } from "@supatype/types"
+import type { Nullable } from "./field-types"
+
+export type User = Model<{ id: UUID; email: Nullable<Email> }>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    const user = ast?.models.find((m) => m.name === "User")
+    expect(user?.fields["email"]).toMatchObject({
+      kind: "email",
+      required: false,
+    })
+  })
+
+  it("resolves import rename of a local type alias", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-rename-local-alias-"))
+    dirs.push(dir)
+    writeFileSync(
+      join(dir, "field-types.ts"),
+      `
+import type { Optional } from "@supatype/types"
+
+export type Nullable<T> = Optional<T>
+`,
+      "utf8",
+    )
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID, Email } from "@supatype/types"
+import type { Nullable as MaybeNull } from "./field-types"
+
+export type User = Model<{ id: UUID; email: MaybeNull<Email> }>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    const user = ast?.models.find((m) => m.name === "User")
+    expect(user?.fields["email"]).toMatchObject({
+      kind: "email",
+      required: false,
+    })
+  })
+
+  it("resolves conditional type aliases via type checker", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-conditional-alias-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID, Email, Optional } from "@supatype/types"
+
+type NullableStr<T> = T extends string ? Optional<T> : T
+
+export type User = Model<{ id: UUID; email: NullableStr<Email> }>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    const user = ast?.models.find((m) => m.name === "User")
+    expect(user?.fields["email"]).toMatchObject({
+      kind: "email",
+      required: false,
+    })
+  })
+
+  it("resolves mapped type aliases as Model fields argument", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-mapped-fields-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID, Email, Optional } from "@supatype/types"
+
+type AllOptional<T> = { [K in keyof T]: Optional<T[K]> }
+
+export type User = Model<AllOptional<{ email: Email; name: string }>>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    const user = ast?.models.find((m) => m.name === "User")
+    expect(user?.fields["email"]).toMatchObject({ kind: "email", required: false })
+    expect(user?.fields["name"]).toMatchObject({ kind: "text", required: false })
+  })
+
+  it("throws on unknown Supatype types instead of silently mapping to TEXT", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-unknown-type-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID } from "@supatype/types"
+
+export type User = Model<{ id: UUID; email: SomeType }>
+`,
+      "utf8",
+    )
+
+    expect(() => extractSchemaAstFromTypes(schemaPath, dir)).toThrow(/Unknown Supatype type "SomeType"/)
+  })
+
+  it("throws on circular type alias chains", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-circular-alias-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID } from "@supatype/types"
+
+type A = B
+type B = A
+
+export type User = Model<{ id: UUID; email: A }>
+`,
+      "utf8",
+    )
+
+    expect(() => extractSchemaAstFromTypes(schemaPath, dir)).toThrow(/circular alias chain/)
+  })
+
+  it("throws on TypeScript utility types used as field types", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-utility-type-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID } from "@supatype/types"
+
+export type User = Model<{ id: UUID; email: NonNullable<string> }>
+`,
+      "utf8",
+    )
+
+    expect(() => extractSchemaAstFromTypes(schemaPath, dir)).toThrow(/Unknown Supatype type "NonNullable"/)
+  })
 })