fix(openapi): key unnamed types by shape, not by the word "Object"

An API with one endpoint returning free-form JSON and another returning an
empty body produces no spec at all. OpenAPISpec() hands back nil, and the
generator's own explanation is that the component name "Object" is pinned to
two different types, "Object and Object", so rename one of them. You cannot
rename either. Neither name was ever pinned.

getQualifiedTypeName returns the literal string "Object" for any type without
a name, and that string is not just a label. It keys the component registry.
So map[string]interface{} and struct{} arrive at the same registry entry,
noteComponent sees a second type claiming a name the first already holds, and
reportPinnedConflict fails the whole document over a collision the user did
not cause and cannot fix.

Unnamed types now key on reflect's own rendering, which is stable for a given
type and different for different ones. The display name stays "Object";
GetTypeName is untouched. Only identity changes.

The tests cover both registration orders, because order is the user's and the
outcome should not be.

Author: juicycleff

internal/router/openapi_anonymous_type_collision_test.go

@@ -0,0 +1,78 @@
+package router
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/xraph/forge/internal/shared"
+)
+
+// Anonymous types have no name of their own, so the generator shows them all as
+// "Object". That is a display choice, and it used to be an identity choice too:
+// every unnamed type keyed the component registry under the same string, so the
+// second one to arrive looked like a different type claiming a name the first
+// already held. The generator reported that as a pinned-name conflict -- advice
+// nobody could act on, since neither name was ever pinned -- and returned no
+// document at all.
+//
+// One endpoint answering with free-form JSON and another answering with an
+// empty body is all it takes, and that pair turns up in almost any real API.
+func registerFreeFormResponse(t *testing.T, r Router) {
+	t.Helper()
+	require.NoError(t, r.GET("/manifest",
+		func(ctx shared.Context, req *collisionEmptyRequest) (*map[string]any, error) {
+			return &map[string]any{}, nil
+		}))
+}
+
+func registerEmptyResponse(t *testing.T, r Router) {
+	t.Helper()
+	require.NoError(t, r.POST("/revoke",
+		func(ctx shared.Context, req *collisionEmptyRequest) (*struct{}, error) {
+			return &struct{}{}, nil
+		}))
+}
+
+func TestOpenAPI_DistinctAnonymousResponsesDoNotCollide(t *testing.T) {
+	for _, tc := range []struct {
+		name     string
+		mapFirst bool
+	}{
+		{name: "MapFirst", mapFirst: true},
+		{name: "StructFirst", mapFirst: false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			r := NewRouter(WithOpenAPI(OpenAPIConfig{Title: "AnonTypes", Version: "1.0.0"}))
+
+			if tc.mapFirst {
+				registerFreeFormResponse(t, r)
+				registerEmptyResponse(t, r)
+			} else {
+				registerEmptyResponse(t, r)
+				registerFreeFormResponse(t, r)
+			}
+
+			spec := r.OpenAPISpec()
+			require.NotNil(t, spec,
+				"two distinct unnamed types were reported as one name conflict, so no spec was generated")
+			requireEveryRefResolves(t, spec)
+		})
+	}
+}
+
+// Generate returns the error alongside the spec, and a caller that asks for the
+// spec twice must get the same answer both times. Guarding it here keeps the
+// registry from carrying conflict state over between passes.
+func TestOpenAPI_AnonymousResponsesGenerateIsRepeatable(t *testing.T) {
+	r := NewRouter(WithOpenAPI(OpenAPIConfig{Title: "AnonRepeat", Version: "1.0.0"}))
+	registerFreeFormResponse(t, r)
+	registerEmptyResponse(t, r)
+
+	first := r.OpenAPISpec()
+	require.NotNil(t, first)
+
+	second := r.OpenAPISpec()
+	require.NotNil(t, second, "a second Generate pass lost the spec the first one produced")
+	require.Equal(t, len(first.Components.Schemas), len(second.Components.Schemas))
+}

internal/router/openapi_schema.go

@@ -1184,7 +1184,13 @@ func getQualifiedTypeName(t reflect.Type) string {
 	typeName := t.Name()
 
 	if typeName == "" {
-		return "Object"
+		// An unnamed type -- map[string]any, struct{}, []T -- has no name to
+		// qualify, and every one of them displays as "Object". That is fine as
+		// a label and wrong as an identity: this string keys the component
+		// registry, so returning a constant made two unrelated types look like
+		// one type claiming a name twice. reflect's own rendering tells them
+		// apart and stays stable for the same type.
+		return t.String()
 	}
 
 	if pkgPath != "" {