fix CreateTemplateByType regression (#1899)

Signed-off-by: grokspawn <jordan@nimblewidget.com>

Author: grokspawn

alpha/template/api/api.go

@@ -3,6 +3,7 @@ package api
 import (
 	"context"
 	"io"
+	"strings"
 
 	"github.com/operator-framework/operator-registry/alpha/declcfg"
 )
@@ -25,6 +26,8 @@ type Template interface {
 	Render(ctx context.Context, reader io.Reader) (*declcfg.DeclarativeConfig, error)
 	// Schema returns the schema identifier for this template type
 	Schema() string
+	// Type returns the registration type for this template (typically the last segment of the schema)
+	Type() string
 }
 
 // Factory creates template instances based on schema
@@ -33,4 +36,12 @@ type Factory interface {
 	CreateTemplate(renderBundle BundleRenderer) Template
 	// Schema returns the schema identifier this factory handles
 	Schema() string
+	// Type returns the registration type for this factory (typically the last segment of the schema)
+	Type() string
+}
+
+// TypeFromSchema extracts the type name from a schema identifier
+// (e.g., "olm.semver" -> "semver")
+func TypeFromSchema(schema string) string {
+	return schema[strings.LastIndex(schema, ".")+1:]
 }

alpha/template/basic/basic.go

@@ -73,6 +73,11 @@ func (t *basicTemplate) Schema() string {
 	return schema
 }
 
+// Type returns the registration type for this template
+func (t *basicTemplate) Type() string {
+	return api.TypeFromSchema(schema)
+}
+
 // Helper functions
 
 func parseSpec(reader io.Reader) (*BasicTemplateData, error) {
@@ -152,3 +157,8 @@ func (f *Factory) CreateTemplate(renderBundle api.BundleRenderer) api.Template {
 func (f *Factory) Schema() string {
 	return schema
 }
+
+// Type returns the registration type for this template
+func (f *Factory) Type() string {
+	return api.TypeFromSchema(schema)
+}

alpha/template/registry.go

@@ -89,13 +89,14 @@ func (r *registry) CreateTemplateBySchema(reader io.Reader, renderBundle BundleR
 
 func (r *registry) CreateTemplateByType(templateType string, renderBundle BundleRenderer) (Template, error) {
 	r.mu.RLock()
-	factory, exists := r.factories[templateType]
 	defer r.mu.RUnlock()
-	if !exists {
-		return nil, &UnknownSchemaError{Schema: templateType}
-	}
 
-	return factory.CreateTemplate(renderBundle), nil
+	for _, f := range r.factories {
+		if f.Type() == templateType {
+			return f.CreateTemplate(renderBundle), nil
+		}
+	}
+	return nil, &UnknownTypeError{Type: templateType}
 }
 
 // GetSupportedSchemas returns all supported schema identifiers
@@ -117,8 +118,8 @@ func (r *registry) GetSupportedTypes() []string {
 	r.mu.RLock()
 	defer r.mu.RUnlock()
 	types := make([]string, 0, len(r.factories))
-	for schema := range r.factories {
-		types = append(types, schema[strings.LastIndex(schema, ".")+1:])
+	for _, f := range r.factories {
+		types = append(types, f.Type())
 	}
 	slices.Sort(types)
 	return types
@@ -144,3 +145,12 @@ type UnknownSchemaError struct {
 func (e *UnknownSchemaError) Error() string {
 	return "unknown template schema: " + e.Schema
 }
+
+// UnknownTypeError is returned when a template type is not recognized
+type UnknownTypeError struct {
+	Type string
+}
+
+func (e *UnknownTypeError) Error() string {
+	return "unknown template type: " + e.Type
+}

alpha/template/registry_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/operator-framework/operator-registry/alpha/declcfg"
+	"github.com/operator-framework/operator-registry/alpha/template/api"
 )
 
 // mockTemplate is a test implementation of the Template interface
@@ -32,6 +33,10 @@ func (m *mockTemplate) Schema() string {
 	return m.schema
 }
 
+func (m *mockTemplate) Type() string {
+	return api.TypeFromSchema(m.schema)
+}
+
 // mockFactory is a test implementation of the TemplateFactory interface
 type mockFactory struct {
 	schema string
@@ -48,6 +53,10 @@ func (f *mockFactory) Schema() string {
 	return f.schema
 }
 
+func (f *mockFactory) Type() string {
+	return api.TypeFromSchema(f.schema)
+}
+
 // newEmptyTemplateRegistry creates an empty template registry for testing purposes.
 // Unlike newEmptyTemplateRegistry(), this does not register any built-in factories.
 func newEmptyTemplateRegistry() *registry {
@@ -118,28 +127,28 @@ func TestTemplateRegistry_CreateTemplateByType(t *testing.T) {
 		{
 			name:         "create template for registered type",
 			setupSchemas: []string{"olm.semver"},
-			requestType:  "olm.semver",
+			requestType:  "semver",
 			expectError:  false,
 		},
 		{
 			name:         "create template for multiple registered types",
-			setupSchemas: []string{"olm.semver", "olm.basic", "olm.composite"},
-			requestType:  "olm.basic",
+			setupSchemas: []string{"olm.semver", "olm.basic", "olm.subtitutes"},
+			requestType:  "basic",
 			expectError:  false,
 		},
 		{
 			name:         "error on unregistered type",
 			setupSchemas: []string{"olm.semver"},
-			requestType:  "olm.unknown",
+			requestType:  "unknown",
 			expectError:  true,
-			expectedErr:  "unknown template schema: olm.unknown",
+			expectedErr:  "unknown template type: unknown",
 		},
 		{
 			name:         "error on empty registry",
 			setupSchemas: []string{},
-			requestType:  "olm.semver",
+			requestType:  "semver",
 			expectError:  true,
-			expectedErr:  "unknown template schema: olm.semver",
+			expectedErr:  "unknown template type: semver",
 		},
 	}
 
@@ -157,13 +166,13 @@ func TestTemplateRegistry_CreateTemplateByType(t *testing.T) {
 				require.Nil(t, template)
 				require.Contains(t, err.Error(), tt.expectedErr)
 
-				var unknownSchemaErr *UnknownSchemaError
-				require.ErrorAs(t, err, &unknownSchemaErr)
-				require.Equal(t, tt.requestType, unknownSchemaErr.Schema)
+				var unknownTypeErr *UnknownTypeError
+				require.ErrorAs(t, err, &unknownTypeErr)
+				require.Equal(t, tt.requestType, unknownTypeErr.Type)
 			} else {
 				require.NoError(t, err)
 				require.NotNil(t, template)
-				require.Equal(t, tt.requestType, template.Schema())
+				require.Equal(t, tt.requestType, template.Type())
 			}
 		})
 	}
@@ -464,7 +473,7 @@ func TestTemplateRegistry_RenderBundlePropagation(t *testing.T) {
 			var err error
 
 			if tt.method == "byType" {
-				template, err = registry.CreateTemplateByType("olm.semver", mockRenderBundle)
+				template, err = registry.CreateTemplateByType("semver", mockRenderBundle)
 				require.NoError(t, err)
 			} else {
 				input := `schema: olm.semver`

alpha/template/semver/semver.go

@@ -123,6 +123,11 @@ func (t *semverTemplate) Schema() string {
 	return schema
 }
 
+// Type returns the registration type for this template
+func (t *semverTemplate) Type() string {
+	return api.TypeFromSchema(schema)
+}
+
 // Helper functions
 
 // channel "archetypes", restricted in this iteration to just these
@@ -621,3 +626,8 @@ func (f *Factory) CreateTemplate(renderBundle api.BundleRenderer) api.Template {
 func (f *Factory) Schema() string {
 	return schema
 }
+
+// Type returns the registration type for this template
+func (f *Factory) Type() string {
+	return api.TypeFromSchema(schema)
+}

alpha/template/substitutes/substitutes.go

@@ -52,6 +52,11 @@ func (t *template) Schema() string {
 	return schema
 }
 
+// Type returns the registration type for this template
+func (t *template) Type() string {
+	return api.TypeFromSchema(schema)
+}
+
 func (t *template) RenderBundle(ctx context.Context, bundleRef string) (*declcfg.DeclarativeConfig, error) {
 	return t.renderBundle(ctx, bundleRef)
 }
@@ -285,3 +290,8 @@ func (f *Factory) CreateTemplate(renderBundle api.BundleRenderer) api.Template {
 func (f *Factory) Schema() string {
 	return schema
 }
+
+// Type returns the registration type for this template
+func (f *Factory) Type() string {
+	return api.TypeFromSchema(schema)
+}