refactor(scripts/typegen): replace local Zod serializer with guts/zod

Delete the hand-rolled zod.go serializer and use zod.AsSchemas from
github.com/coder/guts/zod (PR coder/guts#85) instead. The mutation
rewrites the guts AST to Zod v4 schema nodes, then SerializeInOrder
emits only the wanted types in dependency order.

guts v1.7.0 -> v1.7.1-0.20260529230818-2f30faf483eb (feat/zod-mutation)

Author: mafredri

Makefile

@@ -6,7 +6,7 @@ all: gen build fmt lint test
 
 gen: src/codersdk.gen.ts
 
-src/codersdk.gen.ts: scripts/typegen/main.go scripts/typegen/zod.go scripts/typegen/go.mod
+src/codersdk.gen.ts: scripts/typegen/main.go scripts/typegen/go.mod
 	@cd scripts/typegen && go run . > ../../src/codersdk.gen.ts.tmp
 	@mv src/codersdk.gen.ts.tmp src/codersdk.gen.ts
 	@bun run format -- src/codersdk.gen.ts || true

scripts/typegen/go.mod

@@ -11,7 +11,7 @@ require (
 	github.com/buger/jsonparser v1.1.2 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/coder/coder/v2 v2.34.0-rc.0.0.20260528065010-cfa343e45666 // indirect
-	github.com/coder/guts v1.7.0 // indirect
+	github.com/coder/guts v1.7.1-0.20260529230818-2f30faf483eb // indirect
 	github.com/coder/pretty v0.0.0-20230908205945-e89ba86370e0 // indirect
 	github.com/coder/serpent v0.15.0 // indirect
 	github.com/coder/websocket v1.8.14 // indirect

scripts/typegen/go.sum

@@ -16,6 +16,8 @@ github.com/coder/coder/v2 v2.34.0-rc.0.0.20260528065010-cfa343e45666 h1:imJX12Fi
 github.com/coder/coder/v2 v2.34.0-rc.0.0.20260528065010-cfa343e45666/go.mod h1:5UG9p30Gqu3UoUz0fo18JzD5DBQj2S9ArDtbI8yhIr8=
 github.com/coder/guts v1.7.0 h1:TaZ/PR9wgN8dlbcckaWV1MxkkuEFZRwSRwBBEm8dYXs=
 github.com/coder/guts v1.7.0/go.mod h1:30SShdvpmsauNlsNjECRB5AppScjYk08rf2ZVpH3MFg=
+github.com/coder/guts v1.7.1-0.20260529230818-2f30faf483eb h1:MjlXdlmJwVf24NGrdE+2/spUKJlgNeAmNAx7RtobwoI=
+github.com/coder/guts v1.7.1-0.20260529230818-2f30faf483eb/go.mod h1:VAC7GjXGIoM747tMmabVQHTzb/ZtAQxGaFCiZE9g/C4=
 github.com/coder/pretty v0.0.0-20230908205945-e89ba86370e0 h1:3A0ES21Ke+FxEM8CXx9n47SZOKOpgSE1bbJzlE4qPVs=
 github.com/coder/pretty v0.0.0-20230908205945-e89ba86370e0/go.mod h1:5UuS2Ts+nTToAMeOjNlnHFkPahrtDkmpydBen/3wgZc=
 github.com/coder/serpent v0.15.0 h1:jobR7DnPsxzEMD0cRiailwlY+4v6HAPS/8emIgBpaIU=

scripts/typegen/main.go

@@ -12,11 +12,11 @@ import (
 	"maps"
 	"os"
 	"slices"
-	"strings"
 
 	"github.com/coder/guts"
 	"github.com/coder/guts/bindings"
 	"github.com/coder/guts/config"
+	"github.com/coder/guts/zod"
 )
 
 // Types the action needs from the Coder API. Only root types that
@@ -63,38 +63,46 @@ func main() {
 		log.Fatalf("to typescript: %v", err)
 	}
 
+	// Pre-Zod mutations that reshape enums and optional fields.
 	ts.ApplyMutations(
 		config.EnumAsTypes,
 		config.SimplifyOmitEmpty,
 	)
 
-	// Collect all nodes then filter to wanted types plus any
-	// types they reference that are also in the full set.
+	// Compute wanted types and dependency order before Zod
+	// rewrites the AST (collectRefs works on Interface/Alias).
 	allNodes := make(map[string]bindings.Node)
 	ts.ForEach(func(name string, node bindings.Node) {
 		allNodes[name] = node
 	})
-
-	// Resolve transitive references so we don't emit broken
-	// schema references.
 	included := resolveTransitive(allNodes, wantedTypes)
+	order := topoSort(included)
 
-	// Topological sort: emit dependencies before dependents.
-	names := topoSort(included)
-
-	var b strings.Builder
-	b.WriteString("// Code generated by 'make gen'. DO NOT EDIT.\n")
-	b.WriteString("import { z } from \"zod\";\n\n")
+	// Rewrite Interface/Alias into Zod schemas, then export.
+	ts.ApplyMutations(
+		zod.AsSchemas,
+		config.ExportTypes,
+	)
 
-	for _, name := range names {
-		s := serializeNode(name, included[name])
-		if s != "" {
-			b.WriteString(s)
-			b.WriteString("\n")
+	output, err := ts.SerializeInOrder(func(nodes map[string]bindings.Node) []bindings.Node {
+		var result []bindings.Node
+		for _, name := range order {
+			// AsSchemas creates FooSchema (VariableStatement) and
+			// Foo (Alias with z.infer<typeof FooSchema>).
+			if schema, ok := nodes[name+"Schema"]; ok {
+				result = append(result, schema)
+			}
+			if typeNode, ok := nodes[name]; ok {
+				result = append(result, typeNode)
+			}
 		}
+		return result
+	})
+	if err != nil {
+		log.Fatalf("serialize: %v", err)
 	}
 
-	_, _ = fmt.Fprint(os.Stdout, b.String())
+	_, _ = fmt.Fprint(os.Stdout, output)
 }
 
 // resolveTransitive starts from the seeds and pulls in any

scripts/typegen/main_test.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"strings"
+	"slices"
 	"testing"
 
 	"github.com/coder/guts/bindings"
@@ -86,12 +86,7 @@ func TestTopoSort(t *testing.T) {
 	order := topoSort(nodes)
 
 	indexOf := func(name string) int {
-		for i, n := range order {
-			if n == name {
-				return i
-			}
-		}
-		return -1
+		return slices.Index(order, name)
 	}
 
 	if indexOf("C") > indexOf("B") {
@@ -172,250 +167,6 @@ func TestCollectRefsArrayLiteralType(t *testing.T) {
 	}
 }
 
-func TestExprToZodNullableUnion(t *testing.T) {
-	t.Parallel()
-
-	expr := bindings.Union(kw(bindings.KeywordString), &bindings.Null{})
-	result := exprToZod(expr, "")
-
-	if result != "z.string().nullable()" {
-		t.Errorf("expected z.string().nullable(), got %q", result)
-	}
-}
-
-func TestExprToZodSingleMemberUnion(t *testing.T) {
-	t.Parallel()
-
-	expr := bindings.Union(kw(bindings.KeywordString))
-	result := exprToZod(expr, "")
-
-	if result != "z.string()" {
-		t.Errorf("expected z.string(), got %q", result)
-	}
-}
-
-func TestExprToZodRecord(t *testing.T) {
-	t.Parallel()
-
-	expr := bindings.Reference(
-		bindings.Identifier{Name: "Record"},
-		kw(bindings.KeywordString),
-		kw(bindings.KeywordString),
-	)
-	result := exprToZod(expr, "")
-
-	if result != "z.record(z.string(), z.string())" {
-		t.Errorf("expected z.record(...), got %q", result)
-	}
-}
-
-func TestExprToZodSelfReference(t *testing.T) {
-	t.Parallel()
-
-	expr := ref("Tree")
-	result := exprToZod(expr, "Tree")
-
-	if !strings.Contains(result, "z.lazy") {
-		t.Errorf("expected z.lazy() for self-reference, got %q", result)
-	}
-}
-
-func TestExprToZodNonSelfReference(t *testing.T) {
-	t.Parallel()
-
-	expr := ref("Other")
-	result := exprToZod(expr, "Tree")
-
-	if result != "OtherSchema" {
-		t.Errorf("expected OtherSchema, got %q", result)
-	}
-}
-
-func TestSerializeNodeInterface(t *testing.T) {
-	t.Parallel()
-
-	node := &bindings.Interface{
-		Name: bindings.Identifier{Name: "Foo"},
-		Fields: []*bindings.PropertySignature{
-			{Name: "name", Type: kw(bindings.KeywordString)},
-		},
-	}
-
-	result := serializeNode("Foo", node)
-
-	if !strings.Contains(result, "export const FooSchema = z.object(") {
-		t.Errorf("expected z.object declaration, got:\n%s", result)
-	}
-	if !strings.Contains(result, "name: z.string()") {
-		t.Errorf("expected name field, got:\n%s", result)
-	}
-}
-
-func TestSerializeNodeAlias(t *testing.T) {
-	t.Parallel()
-
-	node := &bindings.Alias{
-		Name: bindings.Identifier{Name: "MyString"},
-		Type: kw(bindings.KeywordString),
-	}
-
-	result := serializeNode("MyString", node)
-
-	if !strings.Contains(result, "export const MyStringSchema = z.string()") {
-		t.Errorf("expected z.string() alias, got:\n%s", result)
-	}
-	if !strings.Contains(result, "export type MyString = z.infer<typeof MyStringSchema>") {
-		t.Errorf("expected type export, got:\n%s", result)
-	}
-}
-
-func TestSerializeNodeUnknownReturnsEmpty(t *testing.T) {
-	t.Parallel()
-
-	// LiteralKeyword is a Node but not Interface or Alias.
-	kword := bindings.KeywordString
-	result := serializeNode("X", &kword)
-
-	if result != "" {
-		t.Errorf("expected empty string for unknown node type, got %q", result)
-	}
-}
-
-func TestSerializeInterfaceWithHeritage(t *testing.T) {
-	t.Parallel()
-
-	iface := &bindings.Interface{
-		Name: bindings.Identifier{Name: "Child"},
-		Heritage: []*bindings.HeritageClause{
-			bindings.HeritageClauseExtends(ref("Parent")),
-		},
-		Fields: []*bindings.PropertySignature{
-			{Name: "extra", Type: kw(bindings.KeywordString)},
-		},
-	}
-
-	result := serializeInterface("Child", iface)
-
-	if !strings.Contains(result, "ParentSchema.extend") {
-		t.Errorf("expected ParentSchema.extend, got:\n%s", result)
-	}
-	if !strings.Contains(result, "extra: z.string()") {
-		t.Errorf("expected extra field, got:\n%s", result)
-	}
-}
-
-func TestSerializeStringEnum(t *testing.T) {
-	t.Parallel()
-
-	union := &bindings.UnionType{
-		Types: []bindings.ExpressionType{
-			&bindings.LiteralType{Value: "a"},
-			&bindings.LiteralType{Value: "b"},
-		},
-	}
-
-	result := serializeStringEnum("Status", union)
-
-	if !strings.Contains(result, `z.enum([`) {
-		t.Errorf("expected z.enum, got:\n%s", result)
-	}
-	if !strings.Contains(result, `"a"`) || !strings.Contains(result, `"b"`) {
-		t.Errorf("expected enum values, got:\n%s", result)
-	}
-}
-
-func TestObjectLiteralToZod(t *testing.T) {
-	t.Parallel()
-
-	tl := &bindings.TypeLiteralNode{
-		Members: []*bindings.PropertySignature{
-			{Name: "x", Type: kw(bindings.KeywordNumber)},
-			{Name: "y", Type: kw(bindings.KeywordString), QuestionToken: true},
-		},
-	}
-
-	result := objectLiteralToZod(tl, "")
-
-	if !strings.Contains(result, "z.object(") {
-		t.Errorf("expected z.object, got:\n%s", result)
-	}
-	if !strings.Contains(result, "x: z.number()") {
-		t.Errorf("expected x field, got:\n%s", result)
-	}
-	if !strings.Contains(result, "y: z.string().optional()") {
-		t.Errorf("expected optional y field, got:\n%s", result)
-	}
-}
-
-func TestIntersectionToZod(t *testing.T) {
-	t.Parallel()
-
-	t.Run("empty", func(t *testing.T) {
-		t.Parallel()
-		inter := &bindings.TypeIntersection{}
-		if got := intersectionToZod(inter, ""); got != "z.unknown()" {
-			t.Errorf("expected z.unknown(), got %q", got)
-		}
-	})
-
-	t.Run("single", func(t *testing.T) {
-		t.Parallel()
-		inter := &bindings.TypeIntersection{
-			Types: []bindings.ExpressionType{kw(bindings.KeywordString)},
-		}
-		if got := intersectionToZod(inter, ""); got != "z.string()" {
-			t.Errorf("expected z.string(), got %q", got)
-		}
-	})
-
-	t.Run("two types", func(t *testing.T) {
-		t.Parallel()
-		inter := &bindings.TypeIntersection{
-			Types: []bindings.ExpressionType{
-				ref("A"),
-				ref("B"),
-			},
-		}
-		got := intersectionToZod(inter, "")
-		if !strings.Contains(got, "z.intersection(ASchema, BSchema)") {
-			t.Errorf("expected z.intersection(ASchema, BSchema), got %q", got)
-		}
-	})
-
-	t.Run("three types nested", func(t *testing.T) {
-		t.Parallel()
-		inter := &bindings.TypeIntersection{
-			Types: []bindings.ExpressionType{
-				ref("A"),
-				ref("B"),
-				ref("C"),
-			},
-		}
-		got := intersectionToZod(inter, "")
-		expected := "z.intersection(z.intersection(ASchema, BSchema), CSchema)"
-		if got != expected {
-			t.Errorf("expected %q, got %q", expected, got)
-		}
-	})
-}
-
-func TestSerializeNodeSelfReferenceUsesLazy(t *testing.T) {
-	t.Parallel()
-
-	node := &bindings.Interface{
-		Name: bindings.Identifier{Name: "Tree"},
-		Fields: []*bindings.PropertySignature{
-			{Name: "children", Type: bindings.Array(ref("Tree"))},
-		},
-	}
-
-	result := serializeNode("Tree", node)
-
-	if !strings.Contains(result, "z.lazy(") {
-		t.Errorf("expected z.lazy for self-reference, got:\n%s", result)
-	}
-}
-
 func ref(name string) *bindings.ReferenceType {
 	return bindings.Reference(bindings.Identifier{Name: name})
 }