feat: add to zss

Author: Oudwins

pkgs/zss/core/zss_structures.go

@@ -63,6 +63,7 @@ type ZSSSchema struct {
 	Element      *ZSSSchema              `json:"element,omitempty"`   // ptr, slice, preprocess, boxed
 	Key          *ZSSSchema              `json:"key,omitempty"`       // map only
 	Value        *ZSSSchema              `json:"value,omitempty"`     // map only
+	Children     []*ZSSSchema            `json:"children,omitempty"`  // union only
 	Required     *ZSSTest                `json:"required,omitempty"`
 	DefaultValue any                     `json:"defaultValue,omitempty"`
 	CatchValue   any                     `json:"catchValue,omitempty"`

pkgs/zss/jsonschema/draft2020_12/jsonschema.go

@@ -91,6 +91,8 @@ func (c converter) convertSchema(schema *zsscore.ZSSSchema) (Schema, error) {
 		out, err = c.convertStruct(schema)
 	case zconst.TypePtr:
 		out, err = c.convertPtr(schema)
+	case zconst.TypeUnion:
+		out, err = c.convertUnion(schema)
 	case zconst.TypePreprocess, zconst.TypeBoxed:
 		out, err = c.convertSchema(schema.Element)
 	case zconst.TypeAny, zconst.TypeCustom:
@@ -187,6 +189,18 @@ func (c converter) convertPtr(schema *zsscore.ZSSSchema) (Schema, error) {
 	return nullable(inner), nil
 }
 
+func (c converter) convertUnion(schema *zsscore.ZSSSchema) (Schema, error) {
+	children := make([]any, 0, len(schema.Children))
+	for i, child := range schema.Children {
+		converted, err := c.convertSchema(child)
+		if err != nil {
+			return nil, fmt.Errorf("convert union child %d: %w", i, err)
+		}
+		children = append(children, converted)
+	}
+	return Schema{"anyOf": children}, nil
+}
+
 func nullable(schema Schema) Schema {
 	typeValue, ok := schema["type"]
 	if !ok {

pkgs/zss/jsonschema/jsonschema_test.go

@@ -84,6 +84,25 @@ func TestFromZSSConvertsContainers(t *testing.T) {
 	}, schema)
 }
 
+func TestFromZSSConvertsUnion(t *testing.T) {
+	doc := zsscore.ZSSDocument{Root: &zsscore.ZSSSchema{Kind: zconst.TypeUnion, Children: []*zsscore.ZSSSchema{
+		{Kind: zconst.TypeString},
+		{Kind: zconst.TypeNumber},
+	}}}
+
+	schema, err := zjsonschema.FromZSS(doc, zjsonschema.Options{})
+	require.NoError(t, err)
+	requireValidJSONSchema(t, schema)
+
+	assert.Equal(t, zjsonschema.Schema{
+		"$schema": string(zjsonschema.Draft2020_12),
+		"anyOf": []any{
+			zjsonschema.Schema{"type": "string"},
+			zjsonschema.Schema{"type": "number"},
+		},
+	}, schema)
+}
+
 func TestFromZSSConvertsPointerNullability(t *testing.T) {
 	optional, err := zjsonschema.FromZSS(zsscore.ZSSDocument{Root: &zsscore.ZSSSchema{Kind: zconst.TypePtr, Element: &zsscore.ZSSSchema{Kind: zconst.TypeString}}}, zjsonschema.Options{})
 	require.NoError(t, err)

pkgs/zss/schema/zss_document_schema.go

@@ -58,6 +58,7 @@ var ZSSSchemaSchema = z.EXPERIMENTAL_RECURSIVE(func(self z.RecursiveSchema[*z.St
 		"element":      z.Ptr(self()),
 		"key":          z.Ptr(self()),
 		"value":        z.Ptr(self()),
+		"children":     z.Slice(z.Ptr(self())),
 		"required":     z.Ptr(ZSSTestSchema),
 		"defaultValue": z.EXPERIMENTAL_ANY(),
 		"catchValue":   z.EXPERIMENTAL_ANY(),

pkgs/zss/toZSS_test.go

@@ -45,6 +45,9 @@ func stripGoTypes(schema *zss.ZSSSchema) {
 	stripGoTypes(schema.Element)
 	stripGoTypes(schema.Key)
 	stripGoTypes(schema.Value)
+	for _, child := range schema.Children {
+		stripGoTypes(child)
+	}
 }
 
 func TestToJsonString(t *testing.T) {
@@ -212,6 +215,32 @@ func TestToJsonBool(t *testing.T) {
 	assert.Equal(t, normalize(expected), normalize(string(serialized)))
 }
 
+func TestToJsonUnion(t *testing.T) {
+	s := zog.Union([]zog.ZogSchema{
+		zog.String(),
+		zog.Int(),
+	})
+	d := zog.EXPERIMENTAL_TO_ZSS[any](s)
+	serialized, err := json.Marshal(withoutGoTypes(d))
+	assert.Nil(t, err)
+	assert.NotNil(t, serialized)
+
+	expected := baseZSSJson(`{
+		"kind": "union",
+		"children": [
+			{
+				"kind": "string"
+			},
+			{
+				"kind": "number"
+			}
+		]
+	}`)
+
+	assert.Equal(t, normalize(expected), normalize(string(serialized)))
+	assert.Nil(t, zssschema.ZSSDocumentSchema.Validate(&d))
+}
+
 func TestToJsonTime(t *testing.T) {
 	s := zog.Time().Required()
 	d := zog.EXPERIMENTAL_TO_ZSS[time.Time](s)

union.go

@@ -85,6 +85,15 @@ func (u *UnionSchema) getType() zconst.ZogType {
 	return zconst.TypeUnion
 }
 func (u *UnionSchema) setCoercer(c CoercerFunc) {}
-func (u *UnionSchema) toZSS(*ZSSSerializeCtx) *zss.ZSSSchema {
-	return &zss.ZSSSchema{}
+
+func (u *UnionSchema) toZSS(ctx *ZSSSerializeCtx) *zss.ZSSSchema {
+	children := make([]*zss.ZSSSchema, 0, len(u.schemas))
+	for _, schema := range u.schemas {
+		children = append(children, schema.toZSS(ctx))
+	}
+
+	return &zss.ZSSSchema{
+		Kind:     zconst.TypeUnion,
+		Children: children,
+	}
 }

zconst/consts.go

@@ -51,6 +51,7 @@ var ZogTypeValues = []ZogType{
 	TypePreprocess,
 	TypeBoxed,
 	TypeAny,
+	TypeUnion,
 }
 
 // Deprecated: This will be removed in the future. Use z.ZogIssueCode instead