feat(codegen): handle shared schemas

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-	".": "0.0.16"
+	".": "0.0.17"
 }

CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.0.17](https://github.com/sumup/sumup-py/compare/v0.0.16...v0.0.17) (2025-12-19)
+
+
+### Features
+
+* **sdk:** improve enum types ([a2d5cf6](https://github.com/sumup/sumup-py/commit/a2d5cf63397decf6c7ad58c880b383b8f7b07591))
+
+
+### Bug Fixes
+
+* transactions entry_mode enum ([05b0f5a](https://github.com/sumup/sumup-py/commit/05b0f5a1fb7543e3cd9948f7d3c7b117e7ccbef5))
+
 ## [0.0.16](https://github.com/sumup/sumup-py/compare/v0.0.15...v0.0.16) (2025-12-18)
 
 

codegen/Makefile

@@ -6,11 +6,15 @@ help: ## Show help
 
 .PHONY: fmt
 fmt: ## Format go files
-	golangci-lint fmt -v
+	golangci-lint fmt --verbose
 
 .PHONY: lint
 lint: ## Lint go files
-	golangci-lint run -v
+	golangci-lint run --verbose
+
+.PHONY: lint-fix
+lint-fix: ## Lint go files and apply auto-fixes
+	golangci-lint run --verbose --fix
 
 .PHONY: test
 test: ## Run tests

codegen/pkg/builder/builder.go

@@ -35,6 +35,10 @@ type Builder struct {
 	templates *template.Template
 
 	start time.Time
+
+	// currentTag is used to track which tag we're currently generating
+	// to determine if we need to add _shared. prefix
+	currentTag string
 }
 
 // Config is builder configuration which configures output options.
@@ -90,6 +94,13 @@ func (b *Builder) Build() error {
 		return fmt.Errorf("missing specs: call Load to load the specs first")
 	}
 
+	// Generate shared schemas first if they exist
+	if sharedSchemas, ok := b.schemasByTag["_shared"]; ok && len(sharedSchemas) > 0 {
+		if err := b.generateSharedResource(sharedSchemas); err != nil {
+			return fmt.Errorf("generate shared resource: %w", err)
+		}
+	}
+
 	for tagName, paths := range b.pathsByTag {
 		if err := b.generateResource(tagName, paths); err != nil {
 			return err

codegen/pkg/builder/collect.go

@@ -49,6 +49,8 @@ func (b *Builder) collectPaths() {
 func (b *Builder) collectSchemas() {
 	// Map of schemas grouped by tag
 	schemasByTag := make(map[string][]*base.SchemaProxy)
+	// Track which tags reference each schema
+	schemaRefs := make(map[string][]string)
 
 	for path, pathItem := range b.spec.Paths.PathItems.FromOldest() {
 		for method, op := range pathItem.GetOperations().FromOldest() {
@@ -78,11 +80,92 @@ func (b *Builder) collectSchemas() {
 					}) {
 						schemasByTag[tagLower] = append(schemasByTag[tagLower], schema)
 					}
+					if !slices.Contains(schemaRefs[schema.GetReference()], tagLower) {
+						schemaRefs[schema.GetReference()] = append(schemaRefs[schema.GetReference()], tagLower)
+					}
+				}
+			}
+		}
+	}
+
+	// Identify schemas that are referenced by multiple tags and move them to shared
+	for schemaRef, tags := range schemaRefs {
+		if len(tags) > 1 {
+			// Remove from individual tags
+			for _, tag := range tags {
+				tagLower := strings.ToLower(tag)
+				idx := slices.IndexFunc(schemasByTag[tagLower], func(sp *base.SchemaProxy) bool {
+					return sp.GetReference() == schemaRef
+				})
+				if idx != -1 {
+					schemasByTag[tagLower] = append(schemasByTag[tagLower][:idx], schemasByTag[tagLower][idx+1:]...)
+				}
+			}
+			// Add to shared
+			if schemasByTag["_shared"] == nil {
+				schemasByTag["_shared"] = make([]*base.SchemaProxy, 0)
+			}
+			// Find the schema proxy to add
+			for _, schemas := range schemasByTag {
+				for _, sp := range schemas {
+					if sp.GetReference() == schemaRef {
+						if !slices.ContainsFunc(schemasByTag["_shared"], func(existing *base.SchemaProxy) bool {
+							return existing.GetReference() == schemaRef
+						}) {
+							schemasByTag["_shared"] = append(schemasByTag["_shared"], sp)
+						}
+						break
+					}
 				}
 			}
 		}
 	}
 
+	// Need to find schemas that were removed from other tags but not added yet
+	for schemaRef, tags := range schemaRefs {
+		if len(tags) > 1 {
+			// Try to find this schema in any tag's collection from the original data
+			var foundSchema *base.SchemaProxy
+			for _, pathItem := range b.spec.Paths.PathItems.FromOldest() {
+				for _, op := range pathItem.GetOperations().FromOldest() {
+					c := make(SchemaProxyCollection, 0, 100)
+					c.collectSchemasInResponse(op)
+					c.collectSchemasInParams(op)
+					c.collectSchemasInRequest(op)
+
+					for _, schema := range c {
+						if schema.GetReference() == schemaRef {
+							foundSchema = schema
+							break
+						}
+					}
+					if foundSchema != nil {
+						break
+					}
+				}
+				if foundSchema != nil {
+					break
+				}
+			}
+
+			if foundSchema != nil && !slices.ContainsFunc(schemasByTag["_shared"], func(sp *base.SchemaProxy) bool {
+				return sp.GetReference() == schemaRef
+			}) {
+				if schemasByTag["_shared"] == nil {
+					schemasByTag["_shared"] = make([]*base.SchemaProxy, 0)
+				}
+				schemasByTag["_shared"] = append(schemasByTag["_shared"], foundSchema)
+			}
+		}
+	}
+
+	// Sort shared schemas to ensure deterministic order
+	if sharedSchemas, ok := schemasByTag["_shared"]; ok {
+		slices.SortFunc(sharedSchemas, func(a, b *base.SchemaProxy) int {
+			return strings.Compare(a.GetReference(), b.GetReference())
+		})
+	}
+
 	b.schemasByTag = schemasByTag
 }
 

codegen/pkg/builder/methods.go

@@ -375,11 +375,17 @@ func (b *Builder) convertToValidPyType(property string, r *base.SchemaProxy) str
 func (b *Builder) getReferenceSchema(v *base.SchemaProxy) string {
 	if v.GoLow().IsReference() {
 		ref := strings.TrimPrefix(v.GetReference(), "#/components/schemas/")
+		typeName := strcase.ToCamel(ref)
 		if len(v.Schema().Enum) > 0 {
-			return strcase.ToCamel(stringx.MakeSingular(ref))
+			typeName = strcase.ToCamel(stringx.MakeSingular(ref))
 		}
 
-		return strcase.ToCamel(ref)
+		// Check if this is a shared schema and we're not generating the shared file itself
+		if b.currentTag != "_shared" && b.isSharedSchema(v) {
+			typeName = "_shared." + typeName
+		}
+
+		return typeName
 	}
 
 	return ""

codegen/pkg/builder/out.go

@@ -16,20 +16,26 @@ import (
 )
 
 type typesTemplateData struct {
-	PackageName string
-	Types       []Writable
-	UsesSecret  bool
+	PackageName  string
+	Types        []Writable
+	UsesSecret   bool
+	UsesShared   bool
+	SharedImport string
 }
 
 func (b *Builder) generateResourceTypes(tag *base.Tag, schemas []*base.SchemaProxy) error {
+	b.currentTag = strings.ToLower(tag.Name)
 	types := b.schemasToTypes(schemas)
 	usesSecret := usesSecretType(types)
+	usesShared, sharedImport := b.usesSharedTypes(types, nil)
 
 	typesBuf := bytes.NewBuffer(nil)
 	if err := b.templates.ExecuteTemplate(typesBuf, "types.py.tmpl", typesTemplateData{
-		PackageName: strcase.ToSnake(tag.Name),
-		Types:       types,
-		UsesSecret:  usesSecret,
+		PackageName:  strcase.ToSnake(tag.Name),
+		Types:        types,
+		UsesSecret:   usesSecret,
+		UsesShared:   usesShared,
+		SharedImport: sharedImport,
 	}); err != nil {
 		return err
 	}
@@ -96,16 +102,19 @@ func (b *Builder) generateResourceIndex(tagName string, resourceTypes []string)
 }
 
 type resourceTemplateData struct {
-	PackageName string
-	TypeNames   []string
-	Params      []Writable
-	Service     string
-	Methods     []*Method
-	UsesSecret  bool
+	PackageName  string
+	TypeNames    []string
+	Params       []Writable
+	Service      string
+	Methods      []*Method
+	UsesSecret   bool
+	UsesShared   bool
+	SharedImport string
 }
 
 func (b *Builder) generateResourceFile(tagName string, paths *v3.Paths) ([]string, error) {
 	tag := b.tagByTagName(tagName)
+	b.currentTag = strings.ToLower(tag.Name)
 
 	resolvedSchemas := b.schemasByTag[tagName]
 	if err := b.generateResourceTypes(tag, b.schemasByTag[tagName]); err != nil {
@@ -143,15 +152,18 @@ func (b *Builder) generateResourceFile(tagName string, paths *v3.Paths) ([]strin
 	)
 
 	usesSecret := usesSecretType(innerTypes)
+	usesShared, sharedImport := b.usesSharedTypes(innerTypes, methods)
 
 	serviceBuf := bytes.NewBuffer(nil)
 	if err := b.templates.ExecuteTemplate(serviceBuf, "resource.py.tmpl", resourceTemplateData{
-		PackageName: strcase.ToSnake(tag.Name),
-		TypeNames:   typeNames,
-		Params:      innerTypes,
-		Service:     strcase.ToCamel(tag.Name),
-		Methods:     methods,
-		UsesSecret:  usesSecret,
+		PackageName:  strcase.ToSnake(tag.Name),
+		TypeNames:    typeNames,
+		Params:       innerTypes,
+		Service:      strcase.ToCamel(tag.Name),
+		Methods:      methods,
+		UsesSecret:   usesSecret,
+		UsesShared:   usesShared,
+		SharedImport: sharedImport,
 	}); err != nil {
 		return nil, err
 	}
@@ -180,6 +192,40 @@ func (b *Builder) generateResourceFile(tagName string, paths *v3.Paths) ([]strin
 	return resourceTypes, nil
 }
 
+func (b *Builder) generateSharedResource(schemas []*base.SchemaProxy) error {
+	b.currentTag = "_shared"
+	types := b.schemasToTypes(schemas)
+	usesSecret := usesSecretType(types)
+
+	slog.Info("generating shared schemas",
+		slog.Int("schema_count", len(schemas)),
+	)
+
+	typesBuf := bytes.NewBuffer(nil)
+	if err := b.templates.ExecuteTemplate(typesBuf, "types.py.tmpl", typesTemplateData{
+		PackageName: "_shared",
+		Types:       types,
+		UsesSecret:  usesSecret,
+	}); err != nil {
+		return err
+	}
+
+	sharedFileName := path.Join(b.cfg.Out, "_shared.py")
+	sharedFile, err := openGeneratedFile(sharedFileName)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		_ = sharedFile.Close()
+	}()
+
+	if _, err := sharedFile.Write(typesBuf.Bytes()); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func (b *Builder) generateResource(tagName string, paths *v3.Paths) error {
 	if tagName == "" {
 		return fmt.Errorf("empty tag name")
@@ -209,24 +255,60 @@ func (b *Builder) generateResource(tagName string, paths *v3.Paths) error {
 }
 
 func usesSecretType(writables []Writable) bool {
-	for _, w := range writables {
-		if writableUsesSecret(w) {
+	return slices.ContainsFunc(writables, writableUsesSecret)
+}
+
+func writableUsesSecret(w Writable) bool {
+	switch typed := w.(type) {
+	case *ClassDeclaration:
+		for _, f := range typed.Fields {
+			if strings.Contains(f.Type, "Secret") {
+				return true
+			}
+		}
+	case *TypeAlias:
+		if strings.Contains(typed.Type, "Secret") {
 			return true
 		}
 	}
 	return false
 }
 
-func writableUsesSecret(w Writable) bool {
+// usesSharedTypes checks if any types or methods reference shared schemas
+// Returns whether shared is used and the import statement if needed
+func (b *Builder) usesSharedTypes(writables []Writable, methods []*Method) (bool, string) {
+	// Check if we have any shared schemas at all
+	if _, ok := b.schemasByTag["_shared"]; !ok {
+		return false, ""
+	}
+
+	// Check writables for _shared references
+	if slices.ContainsFunc(writables, containsSharedRef) {
+		return true, "from .. import _shared"
+	}
+
+	// Check methods for _shared references (only if methods are provided)
+	for _, m := range methods {
+		for _, r := range m.Responses {
+			if r.Type != "" && strings.Contains(r.Type, "_shared.") {
+				return true, "from .. import _shared"
+			}
+		}
+	}
+
+	return false, ""
+}
+
+func containsSharedRef(w Writable) bool {
 	switch typed := w.(type) {
 	case *ClassDeclaration:
 		for _, f := range typed.Fields {
-			if strings.Contains(f.Type, "Secret") {
+			if strings.Contains(f.Type, "_shared.") {
 				return true
 			}
 		}
 	case *TypeAlias:
-		if strings.Contains(typed.Type, "Secret") {
+		if strings.Contains(typed.Type, "_shared.") {
 			return true
 		}
 	}