feat(gen): support non-primitive enums with sum types

Generate proper sum types for object enums where each enum value
becomes a concrete struct variant. Features:

- Automatic discriminator field detection for value-based discrimination
- Concrete struct types for each enum value (e.g., ObjectEnumFoo, ObjectEnumBar)
- Sum type with Type field for variant switching
- Full JSON encoding/decoding with value-based discrimination
- Getter/setter methods for type-safe variant access

For array enums, falls back to jx.Raw since array items typically
don't have discriminator fields.

Fixes #1596

Author: lanej

_testdata/positive/non_primitive_enum.json

@@ -0,0 +1,47 @@
+{
+  "openapi": "3.0.3",
+  "info": {
+    "title": "Non-primitive enum test",
+    "version": "0.1.0"
+  },
+  "paths": {
+    "/test": {
+      "get": {
+        "operationId": "getTest",
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ObjectEnum"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "ObjectEnum": {
+        "description": "An enum of specific object values",
+        "type": "object",
+        "enum": [
+          {"type": "foo", "value": 1},
+          {"type": "bar", "value": 2},
+          {"type": "baz", "value": 3}
+        ]
+      },
+      "ArrayEnum": {
+        "description": "An enum of specific array values",
+        "type": "array",
+        "enum": [
+          [1, 2, 3],
+          ["a", "b", "c"]
+        ]
+      }
+    }
+  }
+}

gen/_template/json/encoders_sum.tmpl

@@ -179,6 +179,32 @@ func (s *{{ $.Name }}) Decode(d *jx.Decoder) error {
 				}
 				{{- end }}
 			{{- end }}
+			{{- range $fieldName, $discriminator := $.SumSpec.ValueDiscriminators }}
+			case {{ quote $fieldName }}:
+				// Value-based discrimination: check enum value
+				if typ := d.Next(); typ != jx.String {
+					return d.Skip()
+				}
+				value, err := d.StrBytes()
+				if err != nil {
+					return err
+				}
+				switch string(value) {
+					{{- range $enumValue, $variantType := $discriminator.ValueToVariant }}
+				case {{ quote $enumValue }}:
+					match := {{ $variantType }}
+					if found && s.Type != match {
+						s.Type = ""
+						return errors.Errorf("multiple oneOf matches: (%v, %v)", s.Type, match)
+					}
+					found = true
+					s.Type = match
+					{{- end }}
+				default:
+					// Unknown enum value, ignore and continue
+				}
+				return nil
+			{{- end }}
 			{{- end }}
 			}
 			return d.Skip()

gen/ir/json.go

@@ -374,6 +374,13 @@ func (j JSON) Sum() SumJSON {
 			Type: SumJSONTypeDiscriminator,
 		}
 	}
+	// Check for field-based discrimination (UniqueFields or ValueDiscriminators on sum type)
+	if len(j.t.SumSpec.UniqueFields) > 0 || len(j.t.SumSpec.ValueDiscriminators) > 0 {
+		return SumJSON{
+			Type: SumJSONFields,
+		}
+	}
+	// Check for unique fields on variants (legacy approach)
 	for _, s := range j.t.SumOf {
 		if len(s.SumSpec.Unique) > 0 {
 			return SumJSON{

gen/ir/type.go

@@ -65,6 +65,20 @@ type SumSpec struct {
 	// Used for generating field-based discrimination in oneOf/anyOf.
 	// Key: field JSON name, Value: list of variants with that unique field
 	UniqueFields map[string][]UniqueFieldVariant
+
+	// ValueDiscriminators maps field names to value-based discriminators.
+	// Used when variants have the same field name and JSON type but different enum values.
+	// Key: field JSON name, Value: ValueDiscriminator with enum value mappings
+	ValueDiscriminators map[string]ValueDiscriminator
+}
+
+// ValueDiscriminator represents a field that discriminates variants by enum value.
+type ValueDiscriminator struct {
+	// FieldName is the JSON field name used for discrimination
+	FieldName string
+	// ValueToVariant maps enum values to variant type constants
+	// Key: enum value (e.g., "active"), Value: variant type constant (e.g., "ActiveStatusResponse")
+	ValueToVariant map[string]string
 }
 
 type ResolvedSumSpecMap struct {

gen/schema_gen.go

@@ -305,11 +305,19 @@ func (g *schemaGen) generate2(name string, schema *jsonschema.Schema) (ret *ir.T
 			jsonschema.Number,
 			jsonschema.Boolean,
 			jsonschema.Null:
-		default:
-			return nil, errors.Wrap(
-				&ErrNotImplemented{Name: "non-primitive enum"},
-				name,
-			)
+			// Primitive enums are handled below
+		case jsonschema.Object:
+			// Non-primitive object enums generate sum types with struct variants.
+			// Each enum value becomes a concrete struct type.
+			t, err := g.nonPrimitiveObjectEnum(name, schema)
+			if err != nil {
+				return nil, errors.Wrap(err, "non-primitive object enum")
+			}
+			return t, nil
+		case jsonschema.Array, jsonschema.Empty:
+			// Array enums and empty type enums are treated as "any" type.
+			// The enum constraint is documented in OpenAPI but not enforced at runtime.
+			return g.regtype(name, ir.Any(schema)), nil
 		}
 	}
 
@@ -709,3 +717,209 @@ func (g *schemaGen) checkDefaultType(s *jsonschema.Schema, val any) error {
 
 	return nil
 }
+
+// nonPrimitiveObjectEnum generates a sum type for object enums.
+// Each enum value becomes a concrete struct variant.
+func (g *schemaGen) nonPrimitiveObjectEnum(name string, schema *jsonschema.Schema) (*ir.Type, error) {
+	if len(schema.Enum) == 0 {
+		return nil, errors.New("enum has no values")
+	}
+
+	// Convert enum values to map[string]any
+	enumObjects := make([]map[string]any, 0, len(schema.Enum))
+	for i, v := range schema.Enum {
+		obj, ok := v.(map[string]any)
+		if !ok {
+			return nil, errors.Errorf("enum[%d]: expected object, got %T", i, v)
+		}
+		enumObjects = append(enumObjects, obj)
+	}
+
+	// Find a discriminating field - a string field with unique values across all variants
+	discriminatorField, variantNames := findEnumDiscriminator(enumObjects)
+	if discriminatorField == "" {
+		// No discriminator found, fall back to index-based naming
+		for i := range enumObjects {
+			variantNames = append(variantNames, fmt.Sprintf("Variant%d", i))
+		}
+	}
+
+	// Create the sum type
+	sum := g.regtype(name, &ir.Type{
+		Name:   name,
+		Kind:   ir.KindSum,
+		Schema: schema,
+	})
+
+	// Generate struct types for each enum value
+	variants := make([]*ir.Type, 0, len(enumObjects))
+	for i, obj := range enumObjects {
+		variantName := name + variantNames[i]
+		variantSchema := inferSchemaFromObject(obj)
+
+		// Generate the variant struct type
+		variantType := &ir.Type{
+			Kind:   ir.KindStruct,
+			Name:   variantName,
+			Schema: variantSchema,
+		}
+
+		// Add fields from the object
+		for fieldName, fieldValue := range obj {
+			fieldSchema := inferSchemaFromValue(fieldValue)
+			fieldType := g.inferTypeFromValue(fieldValue, fieldSchema)
+
+			field := &ir.Field{
+				Name: naming.Capitalize(fieldName),
+				Type: fieldType,
+				Tag: ir.Tag{
+					JSON: fieldName,
+				},
+				Spec: &jsonschema.Property{
+					Name:     fieldName,
+					Schema:   fieldSchema,
+					Required: true,
+				},
+			}
+			variantType.Fields = append(variantType.Fields, field)
+		}
+
+		// Register and add to variants
+		g.regtype(variantName, variantType)
+		variants = append(variants, variantType)
+	}
+
+	sum.SumOf = variants
+
+	// Set up discrimination
+	if discriminatorField != "" {
+		// Value-based discrimination on the discriminator field
+		valueToVariant := make(map[string]string)
+		for i, obj := range enumObjects {
+			if val, ok := obj[discriminatorField].(string); ok {
+				valueToVariant[val] = variants[i].Name + name
+			}
+		}
+		sum.SumSpec.ValueDiscriminators = map[string]ir.ValueDiscriminator{
+			discriminatorField: {
+				FieldName:      discriminatorField,
+				ValueToVariant: valueToVariant,
+			},
+		}
+	} else {
+		// No discriminator field found, use type-based discrimination as fallback
+		sum.SumSpec.TypeDiscriminator = true
+	}
+
+	return sum, nil
+}
+
+// findEnumDiscriminator finds a string field that has unique values across all enum objects.
+func findEnumDiscriminator(objects []map[string]any) (string, []string) {
+	if len(objects) == 0 {
+		return "", nil
+	}
+
+	// Find all string fields present in all objects
+	stringFields := make(map[string][]string)
+	for _, obj := range objects {
+		for k, v := range obj {
+			if s, ok := v.(string); ok {
+				stringFields[k] = append(stringFields[k], s)
+			}
+		}
+	}
+
+	// Find a field with unique values across all objects
+	for field, values := range stringFields {
+		if len(values) != len(objects) {
+			continue // Field not present in all objects
+		}
+
+		// Check if all values are unique
+		seen := make(map[string]bool)
+		allUnique := true
+		for _, v := range values {
+			if seen[v] {
+				allUnique = false
+				break
+			}
+			seen[v] = true
+		}
+
+		if allUnique {
+			// Use these values as variant names (capitalized)
+			variantNames := make([]string, len(values))
+			for i, v := range values {
+				variantNames[i] = naming.Capitalize(v)
+			}
+			return field, variantNames
+		}
+	}
+
+	return "", nil
+}
+
+// inferSchemaFromObject creates a jsonschema.Schema from an object literal.
+func inferSchemaFromObject(obj map[string]any) *jsonschema.Schema {
+	schema := &jsonschema.Schema{
+		Type: jsonschema.Object,
+	}
+	for fieldName, fieldValue := range obj {
+		prop := jsonschema.Property{
+			Name:     fieldName,
+			Schema:   inferSchemaFromValue(fieldValue),
+			Required: true,
+		}
+		schema.Properties = append(schema.Properties, prop)
+	}
+	return schema
+}
+
+// inferSchemaFromValue creates a jsonschema.Schema from a JSON value.
+func inferSchemaFromValue(v any) *jsonschema.Schema {
+	switch val := v.(type) {
+	case string:
+		return &jsonschema.Schema{Type: jsonschema.String}
+	case int64:
+		return &jsonschema.Schema{Type: jsonschema.Integer}
+	case float64:
+		return &jsonschema.Schema{Type: jsonschema.Number}
+	case bool:
+		return &jsonschema.Schema{Type: jsonschema.Boolean}
+	case nil:
+		return &jsonschema.Schema{Type: jsonschema.Null}
+	case []any:
+		schema := &jsonschema.Schema{Type: jsonschema.Array}
+		if len(val) > 0 {
+			schema.Item = inferSchemaFromValue(val[0])
+		}
+		return schema
+	case map[string]any:
+		return inferSchemaFromObject(val)
+	default:
+		return &jsonschema.Schema{}
+	}
+}
+
+// inferTypeFromValue creates an ir.Type from a JSON value.
+func (g *schemaGen) inferTypeFromValue(v any, schema *jsonschema.Schema) *ir.Type {
+	switch v.(type) {
+	case string:
+		return ir.Primitive(ir.String, schema)
+	case int64:
+		return ir.Primitive(ir.Int64, schema)
+	case float64:
+		return ir.Primitive(ir.Float64, schema)
+	case bool:
+		return ir.Primitive(ir.Bool, schema)
+	case nil:
+		return ir.Primitive(ir.Null, schema)
+	case []any:
+		return ir.Array(g.inferTypeFromValue(nil, nil), ir.NilInvalid, schema)
+	case map[string]any:
+		return ir.Any(schema)
+	default:
+		return ir.Any(schema)
+	}
+}

internal/integration/generate.go

@@ -50,3 +50,4 @@ package integration
 //go:generate go run ../../cmd/ogen -v --clean --target test_issue1161 ../../_testdata/positive/issue1161.json
 //go:generate go run ../../cmd/ogen -v --clean --target test_issue1495 ../../_testdata/positive/issue1495.yml
 //go:generate go run ../../cmd/ogen -v --clean --target test_raw_response ../../_testdata/positive/raw_response.yml
+//go:generate go run ../../cmd/ogen -v --clean --target test_non_primitive_enum ../../_testdata/positive/non_primitive_enum.json