fix(output-options): correctly reference x-go-type-skip-optional-pointer in allOf (oapi-codegen#2042)

If using the global `prefer-skip-optional-pointer: true` alongside a
field-level `x-go-type-skip-optional-pointer: false` on a type that's
referenced by an `allOf`, we don't correctly follow the field-level type
reference and override the value.

This correctly generates the type.

Co-authored-by: Jamie Tanna <jamie.tanna@elastic.co>

Author: magnetikonline

examples/output-options/preferskipoptionalpointer/api.yaml

@@ -37,3 +37,31 @@ components:
         client:
           description: This field is optional, but the `prefer-skip-optional-pointer` Output Option ensures that this should not have an optional pointer.
           $ref: '#/components/schemas/Client'
+    ReferencesATypeWithAnExtensionInsideAllOf:
+      type: object
+      description: This type has a field which references - via an `allOf` - a type which should have an optional pointer, as the field-level definition of `x-go-type-skip-optional-pointer` overrides the `prefer-skip-optional-pointer` Output Option, as well as a field without that property.
+      additionalProperties: false
+      required:
+        - description
+      properties:
+        noExtension:
+          # NOTE this will not generate pointer type as global preference `prefer-skip-optional-pointer: true`
+          allOf:
+            - $ref: '#/components/schemas/ReferencedWithoutExtension'
+        withExtensionPointer:
+          # NOTE this will generate pointer type (despite global preference `prefer-skip-optional-pointer: true`) as we have field-level `x-go-type-skip-optional-pointer: false`
+          allOf:
+            - $ref: '#/components/schemas/ReferencedWithExtension'
+    ReferencedWithoutExtension:
+      type: object
+      additionalProperties: false
+      properties:
+        foo:
+          type: string
+    ReferencedWithExtension:
+      type: object
+      additionalProperties: false
+      properties:
+        foo:
+          type: string
+      x-go-type-skip-optional-pointer: false

examples/output-options/preferskipoptionalpointer/gen.go

@@ -80,6 +80,42 @@ func TestNestedType(t *testing.T) {
 	})
 }
 
+func TestReferencesATypeWithAnExtension(t *testing.T) {
+	t.Run("zero value", func(t *testing.T) {
+		typeWithExt := ReferencesATypeWithAnExtensionInsideAllOf{}
+
+		assert.Zero(t, typeWithExt)
+		assert.Zero(t, typeWithExt.NoExtension)
+		assert.Nil(t, typeWithExt.WithExtensionPointer)
+	})
+
+	t.Run("value on noExtension", func(t *testing.T) {
+		typeWithExt := ReferencesATypeWithAnExtensionInsideAllOf{
+			NoExtension:          ReferencedWithoutExtension{"value"},
+			WithExtensionPointer: nil,
+		}
+
+		b, err := json.Marshal(typeWithExt)
+		require.NoError(t, err)
+
+		assert.True(t, jsonContainsKey(b, "noExtension"))
+		assert.False(t, jsonContainsKey(b, "withExtensionPointer"))
+	})
+
+	t.Run("value on noExtension and withExtensionPointer", func(t *testing.T) {
+		typeWithExt := ReferencesATypeWithAnExtensionInsideAllOf{
+			NoExtension:          ReferencedWithoutExtension{"value"},
+			WithExtensionPointer: &ReferencedWithExtension{"ptrValue"},
+		}
+
+		b, err := json.Marshal(typeWithExt)
+		require.NoError(t, err)
+
+		assert.True(t, jsonContainsKey(b, "noExtension"))
+		assert.True(t, jsonContainsKey(b, "withExtensionPointer"))
+	})
+}
+
 // jsonContainsKey checks if the given JSON object contains the specified key at the top level.
 func jsonContainsKey(b []byte, key string) bool {
 	var m map[string]any

examples/output-options/preferskipoptionalpointer/gen_test.go

@@ -260,6 +260,18 @@ func GenerateGoSchema(sref *openapi3.SchemaRef, path []string) (Schema, error) {
 
 	schema := sref.Value
 
+	// Check x-go-type-skip-optional-pointer, which will override if the type
+	// should be a pointer or not when the field is optional.
+	// NOTE skipOptionalPointer will be defaulted to the global value, but can be overridden on a per-type/-field basis
+	skipOptionalPointer := globalState.options.OutputOptions.PreferSkipOptionalPointer
+	if extension, ok := schema.Extensions[extPropGoTypeSkipOptionalPointer]; ok {
+		var err error
+		skipOptionalPointer, err = extParsePropGoTypeSkipOptionalPointer(extension)
+		if err != nil {
+			return Schema{}, fmt.Errorf("invalid value for %q: %w", extPropGoTypeSkipOptionalPointer, err)
+		}
+	}
+
 	// If Ref is set on the SchemaRef, it means that this type is actually a reference to
 	// another type. We're not de-referencing, so simply use the referenced type.
 	if IsGoTypeReference(sref.Ref) {
@@ -274,15 +286,14 @@ func GenerateGoSchema(sref *openapi3.SchemaRef, path []string) (Schema, error) {
 			Description:         schema.Description,
 			DefineViaAlias:      true,
 			OAPISchema:          schema,
-			SkipOptionalPointer: globalState.options.OutputOptions.PreferSkipOptionalPointer,
+			SkipOptionalPointer: skipOptionalPointer,
 		}, nil
 	}
 
 	outSchema := Schema{
-		Description: schema.Description,
-		OAPISchema:  schema,
-		// NOTE that SkipOptionalPointer will be defaulted to the global value, but can be overridden on a per-type/-field basis
-		SkipOptionalPointer: globalState.options.OutputOptions.PreferSkipOptionalPointer,
+		Description:         schema.Description,
+		OAPISchema:          schema,
+		SkipOptionalPointer: skipOptionalPointer,
 	}
 
 	// AllOf is interesting, and useful. It's the union of a number of other
@@ -298,16 +309,6 @@ func GenerateGoSchema(sref *openapi3.SchemaRef, path []string) (Schema, error) {
 		return mergedSchema, nil
 	}
 
-	// Check x-go-type-skip-optional-pointer, which will override if the type
-	// should be a pointer or not when the field is optional.
-	if extension, ok := schema.Extensions[extPropGoTypeSkipOptionalPointer]; ok {
-		skipOptionalPointer, err := extParsePropGoTypeSkipOptionalPointer(extension)
-		if err != nil {
-			return outSchema, fmt.Errorf("invalid value for %q: %w", extPropGoTypeSkipOptionalPointer, err)
-		}
-		outSchema.SkipOptionalPointer = skipOptionalPointer
-	}
-
 	// Check x-go-type, which will completely override the definition of this
 	// schema with the provided type.
 	if extension, ok := schema.Extensions[extPropGoType]; ok {