fix: fixed inlining shared schemas and improvements to sequenced maps

Author: TristanSpeakEasy

jsonschema/oas3/inline.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"io"
 	"io/fs"
+	"os"
 	"path/filepath"
 	"strings"
 	"testing"
@@ -1375,3 +1376,85 @@ func extractSchemaFromOpenAPI(openAPIDoc *openapi.OpenAPI, pointer string) (*oas
 
 	return schema, nil
 }
+
+func TestInline_EmailParser_PagerDuty_Success(t *testing.T) {
+	t.Parallel()
+
+	// This test reproduces the bug with EmailParser schema from pagerduty.json
+	// The EmailParser schema contains a reference to MatchPredicate, which has a circular reference
+	// through its "children" property that references back to itself
+	ctx := t.Context()
+
+	// Read the pagerduty.json file content
+	pagerDutyContent, err := os.ReadFile("testdata/pagerduty.json")
+	require.NoError(t, err, "failed to read pagerduty.json")
+
+	// Parse as OpenAPI document
+	pagerDutyDoc, err := parseJSONToOpenAPI(ctx, string(pagerDutyContent))
+	require.NoError(t, err, "failed to parse pagerduty.json as OpenAPI")
+
+	// Extract multiple schemas that all use the Integration schema to trigger the bug
+	// when the same MatchPredicate gets processed multiple times in the same session
+
+	// PUT /services/{id}/integrations/{integration_id} requestBody
+	putRequestBodySchema, err := extractSchemaFromOpenAPI(pagerDutyDoc, "/paths/~1services~1{id}~1integrations~1{integration_id}/put/requestBody/content/application~1json/schema")
+	require.NoError(t, err, "failed to extract PUT requestBody schema")
+
+	// POST /services/{id}/integrations requestBody (same Integration schema)
+	postRequestBodySchema, err := extractSchemaFromOpenAPI(pagerDutyDoc, "/paths/~1services~1{id}~1integrations/post/requestBody/content/application~1json/schema")
+	require.NoError(t, err, "failed to extract POST requestBody schema")
+
+	// POST /services/{id}/integrations 201 response (also uses Integration schema)
+	postResponseSchema, err := extractSchemaFromOpenAPI(pagerDutyDoc, "/paths/~1services~1{id}~1integrations/post/responses/201/content/application~1json/schema")
+	require.NoError(t, err, "failed to extract POST 201 response schema")
+
+	// Create resolve options using the pagerduty document as the root document
+	opts := oas3.InlineOptions{
+		ResolveOptions: oas3.ResolveOptions{
+			TargetLocation: "testdata/pagerduty.json",
+			RootDocument:   pagerDutyDoc,
+		},
+		RemoveUnusedDefs: true,
+	}
+
+	// First, inline the PUT requestBody schema
+	inlined1, err := oas3.Inline(ctx, putRequestBodySchema, opts)
+	require.NoError(t, err, "first inlining should succeed for PUT requestBody schema")
+	require.NotNil(t, inlined1, "first inlined schema should not be nil")
+
+	// Then, inline the POST requestBody schema in the same session
+	// This should trigger the bug because MatchPredicate gets processed again
+	inlined2, err := oas3.Inline(ctx, postRequestBodySchema, opts)
+	require.NoError(t, err, "second inlining should succeed for POST requestBody schema")
+	require.NotNil(t, inlined2, "second inlined schema should not be nil")
+
+	// Finally, inline the POST response schema in the same session
+	// This is the third time the same Integration->EmailParser->MatchPredicate chain gets processed
+	inlined3, err := oas3.Inline(ctx, postResponseSchema, opts)
+	require.NoError(t, err, "third inlining should succeed for POST response schema")
+	require.NotNil(t, inlined3, "third inlined schema should not be nil")
+
+	// Verify all results are valid
+	actualJSON1, err := schemaToJSON(ctx, inlined1)
+	require.NoError(t, err, "failed to convert first inlined result to JSON")
+	require.NotEmpty(t, actualJSON1, "first inlined JSON should not be empty")
+
+	actualJSON2, err := schemaToJSON(ctx, inlined2)
+	require.NoError(t, err, "failed to convert second inlined result to JSON")
+	require.NotEmpty(t, actualJSON2, "second inlined JSON should not be empty")
+
+	actualJSON3, err := schemaToJSON(ctx, inlined3)
+	require.NoError(t, err, "failed to convert third inlined result to JSON")
+	require.NotEmpty(t, actualJSON3, "third inlined JSON should not be empty")
+
+	// All schemas should contain the Integration structure with EmailParser inlined
+	for i, actualJSON := range []string{actualJSON1, actualJSON2, actualJSON3} {
+		assert.Contains(t, actualJSON, `"integration"`, "schema %d should contain integration property", i+1)
+		assert.Contains(t, actualJSON, `"action"`, "schema %d should contain action property from inlined EmailParser", i+1)
+		assert.Contains(t, actualJSON, `"match_predicate"`, "schema %d should contain match_predicate property", i+1)
+	}
+
+	t.Logf("Successfully inlined 3 schemas with shared Integration->EmailParser->MatchPredicate references")
+	t.Logf("PUT request: %d chars, POST request: %d chars, POST response: %d chars",
+		len(actualJSON1), len(actualJSON2), len(actualJSON3))
+}

jsonschema/oas3/inline_test.go

@@ -216,3 +216,38 @@ func (j *JSONSchema[T]) Validate(ctx context.Context, opts ...validation.Option)
 func ConcreteToReferenceable(concrete *JSONSchema[Concrete]) *JSONSchema[Referenceable] {
 	return (*JSONSchema[Referenceable])(unsafe.Pointer(concrete)) //nolint:gosec
 }
+
+// ReferenceableToConcrete converts a JSONSchema[Referenceable] to JSONSchema[Concrete] using unsafe pointer casting.
+// This is safe because the underlying structure is identical, only the type parameter differs.
+// This allows for efficient conversion without allocation when you need to walk a referenceable schema
+// as if it were a concrete schema.
+func ReferenceableToConcrete(referenceable *JSONSchema[Referenceable]) *JSONSchema[Concrete] {
+	return (*JSONSchema[Concrete])(unsafe.Pointer(referenceable)) //nolint:gosec
+}
+
+// ShallowCopy creates a shallow copy of the JSONSchema.
+func (j *JSONSchema[T]) ShallowCopy() *JSONSchema[T] {
+	if j == nil {
+		return nil
+	}
+
+	result := &JSONSchema[T]{
+		referenceResolutionCache: j.referenceResolutionCache,
+		validationErrsCache:      j.validationErrsCache,
+		circularErrorFound:       j.circularErrorFound,
+		resolvedSchemaCache:      j.resolvedSchemaCache,
+		parent:                   j.parent,
+		topLevelParent:           j.topLevelParent,
+	}
+
+	// Shallow copy the EitherValue contents
+	if j.IsLeft() && j.GetLeft() != nil {
+		result.Left = j.GetLeft().ShallowCopy()
+	}
+	if j.IsRight() && j.GetRight() != nil {
+		rightVal := *j.GetRight()
+		result.Right = &rightVal
+	}
+
+	return result
+}

jsonschema/oas3/jsonschema.go

@@ -74,6 +74,108 @@ type Schema struct {
 	Extensions            *extensions.Extensions
 }
 
+// ShallowCopy creates a shallow copy of the Schema.
+// This copies all struct fields and creates new slices/maps but does not deep copy the referenced objects.
+// The elements within slices and maps are copied by reference, not deep copied.
+func (s *Schema) ShallowCopy() *Schema {
+	if s == nil {
+		return nil
+	}
+
+	result := &Schema{
+		Model:                 s.Model,
+		Ref:                   s.Ref,
+		ExclusiveMaximum:      s.ExclusiveMaximum,
+		ExclusiveMinimum:      s.ExclusiveMinimum,
+		Type:                  s.Type,
+		Discriminator:         s.Discriminator,
+		Contains:              s.Contains,
+		MinContains:           s.MinContains,
+		MaxContains:           s.MaxContains,
+		If:                    s.If,
+		Else:                  s.Else,
+		Then:                  s.Then,
+		PropertyNames:         s.PropertyNames,
+		UnevaluatedItems:      s.UnevaluatedItems,
+		UnevaluatedProperties: s.UnevaluatedProperties,
+		Items:                 s.Items,
+		Anchor:                s.Anchor,
+		Not:                   s.Not,
+		Title:                 s.Title,
+		MultipleOf:            s.MultipleOf,
+		Maximum:               s.Maximum,
+		Minimum:               s.Minimum,
+		MaxLength:             s.MaxLength,
+		MinLength:             s.MinLength,
+		Pattern:               s.Pattern,
+		Format:                s.Format,
+		MaxItems:              s.MaxItems,
+		MinItems:              s.MinItems,
+		UniqueItems:           s.UniqueItems,
+		MaxProperties:         s.MaxProperties,
+		MinProperties:         s.MinProperties,
+		AdditionalProperties:  s.AdditionalProperties,
+		Description:           s.Description,
+		Default:               s.Default,
+		Const:                 s.Const,
+		Nullable:              s.Nullable,
+		ReadOnly:              s.ReadOnly,
+		WriteOnly:             s.WriteOnly,
+		ExternalDocs:          s.ExternalDocs,
+		Example:               s.Example,
+		Deprecated:            s.Deprecated,
+		Schema:                s.Schema,
+		XML:                   s.XML,
+		Extensions:            s.Extensions,
+	}
+
+	// Shallow copy slices - create new slice but reference same elements
+	if s.AllOf != nil {
+		result.AllOf = make([]*JSONSchema[Referenceable], len(s.AllOf))
+		copy(result.AllOf, s.AllOf)
+	}
+	if s.OneOf != nil {
+		result.OneOf = make([]*JSONSchema[Referenceable], len(s.OneOf))
+		copy(result.OneOf, s.OneOf)
+	}
+	if s.AnyOf != nil {
+		result.AnyOf = make([]*JSONSchema[Referenceable], len(s.AnyOf))
+		copy(result.AnyOf, s.AnyOf)
+	}
+	if s.Examples != nil {
+		result.Examples = make([]values.Value, len(s.Examples))
+		copy(result.Examples, s.Examples)
+	}
+	if s.PrefixItems != nil {
+		result.PrefixItems = make([]*JSONSchema[Referenceable], len(s.PrefixItems))
+		copy(result.PrefixItems, s.PrefixItems)
+	}
+	if s.Required != nil {
+		result.Required = make([]string, len(s.Required))
+		copy(result.Required, s.Required)
+	}
+	if s.Enum != nil {
+		result.Enum = make([]values.Value, len(s.Enum))
+		copy(result.Enum, s.Enum)
+	}
+
+	// Shallow copy maps - create new map but reference same elements
+	if s.DependentSchemas != nil {
+		result.DependentSchemas = sequencedmap.From(s.DependentSchemas.All())
+	}
+	if s.PatternProperties != nil {
+		result.PatternProperties = sequencedmap.From(s.PatternProperties.All())
+	}
+	if s.Properties != nil {
+		result.Properties = sequencedmap.From(s.Properties.All())
+	}
+	if s.Defs != nil {
+		result.Defs = sequencedmap.From(s.Defs.All())
+	}
+
+	return result
+}
+
 // GetRef returns the value of the Ref field. Returns empty string if not set.
 func (s *Schema) GetRef() references.Reference {
 	if s == nil || s.Ref == nil {

jsonschema/oas3/schema.go

@@ -0,0 +1,39 @@
+package oas3_test
+
+import (
+	"testing"
+
+	"github.com/speakeasy-api/openapi/jsonschema/oas3"
+	"github.com/speakeasy-api/openapi/sequencedmap"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestJSONSchema_ShallowCopy_Success(t *testing.T) {
+	t.Parallel()
+
+	// Create a JSONSchema with properties
+	original := oas3.NewJSONSchemaFromSchema[oas3.Referenceable](&oas3.Schema{
+		Type: oas3.NewTypeFromString("object"),
+		Properties: sequencedmap.New(
+			sequencedmap.NewElem("name", oas3.NewJSONSchemaFromSchema[oas3.Referenceable](&oas3.Schema{
+				Type: oas3.NewTypeFromString("string"),
+			})),
+		),
+	})
+
+	// Create a shallow copy
+	copied := original.ShallowCopy()
+	require.NotNil(t, copied, "shallow copy should not be nil")
+
+	// Initially they should be equal
+	assert.True(t, original.IsEqual(copied), "original and copy should be equal initially")
+
+	// Modify the copy by adding a new property
+	copied.GetLeft().Properties.Set("email", oas3.NewJSONSchemaFromSchema[oas3.Referenceable](&oas3.Schema{
+		Type: oas3.NewTypeFromString("string"),
+	}))
+
+	// Now they should not be equal
+	assert.False(t, original.IsEqual(copied), "original and copy should not be equal after modification")
+}