Skip to content

chore(jsonschema): add convenience methods for schema and boolean value access #57

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Oct 9, 2025
Merged

chore(jsonschema): add convenience methods for schema and boolean value access #57

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
5ed4624
chore(jsonschema): add convenience methods for schema and boolean val…
TristanSpeakEasy Oct 9, 2025
adacd76
fix: fixed examples
TristanSpeakEasy Oct 9, 2025
47a7ef9
fix
TristanSpeakEasy Oct 9, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
96 changes: 48 additions & 48 deletions jsonschema/oas3/defs_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -27,9 +27,9 @@ func TestSchema_Defs_Success(t *testing.T) {

// Navigate to the user property which references #/$defs/User
rootSchema := root.MustGetResolvedSchema()
require.True(t, rootSchema.IsLeft())
require.True(t, rootSchema.IsSchema())

properties := rootSchema.GetLeft().GetProperties()
properties := rootSchema.GetSchema().GetProperties()
require.NotNil(t, properties)

userProperty, exists := properties.Get("user")
Expand All @@ -44,10 +44,10 @@ func TestSchema_Defs_Success(t *testing.T) {
// Get the resolved schema
result := userProperty.GetResolvedSchema()
require.NotNil(t, result)
assert.True(t, result.IsLeft())
assert.True(t, result.IsSchema())

// Verify it's the User schema
resolvedSchema := result.GetLeft()
resolvedSchema := result.GetSchema()
assert.Equal(t, []SchemaType{SchemaTypeObject}, resolvedSchema.GetType())

// Verify it has the expected properties
Expand All @@ -56,13 +56,13 @@ func TestSchema_Defs_Success(t *testing.T) {

nameProperty, exists := resolvedProperties.Get("name")
require.True(t, exists)
assert.True(t, nameProperty.IsLeft())
assert.Equal(t, []SchemaType{SchemaTypeString}, nameProperty.GetLeft().GetType())
assert.True(t, nameProperty.IsSchema())
assert.Equal(t, []SchemaType{SchemaTypeString}, nameProperty.GetSchema().GetType())

ageProperty, exists := resolvedProperties.Get("age")
require.True(t, exists)
assert.True(t, ageProperty.IsLeft())
assert.Equal(t, []SchemaType{SchemaTypeInteger}, ageProperty.GetLeft().GetType())
assert.True(t, ageProperty.IsSchema())
assert.Equal(t, []SchemaType{SchemaTypeInteger}, ageProperty.GetSchema().GetType())
})

t.Run("resolve chained references through $defs", func(t *testing.T) {
Expand All @@ -78,9 +78,9 @@ func TestSchema_Defs_Success(t *testing.T) {

// Navigate to the user property which references User, which itself references Address
rootSchema := root.MustGetResolvedSchema()
require.True(t, rootSchema.IsLeft())
require.True(t, rootSchema.IsSchema())

properties := rootSchema.GetLeft().GetProperties()
properties := rootSchema.GetSchema().GetProperties()
require.NotNil(t, properties)

userProperty, exists := properties.Get("user")
Expand All @@ -95,10 +95,10 @@ func TestSchema_Defs_Success(t *testing.T) {
// Get the resolved User schema
userResult := userProperty.GetResolvedSchema()
require.NotNil(t, userResult)
assert.True(t, userResult.IsLeft())
assert.True(t, userResult.IsSchema())

// Verify the User schema has an address property that references Address
userSchema := userResult.GetLeft()
userSchema := userResult.GetSchema()
userProperties := userSchema.GetProperties()
require.NotNil(t, userProperties)

Expand All @@ -123,9 +123,9 @@ func TestSchema_Defs_Success(t *testing.T) {

// Navigate to the chainedRef property which references ChainedRef -> ChainedTarget
rootSchema := root.MustGetResolvedSchema()
require.True(t, rootSchema.IsLeft())
require.True(t, rootSchema.IsSchema())

properties := rootSchema.GetLeft().GetProperties()
properties := rootSchema.GetSchema().GetProperties()
require.NotNil(t, properties)

chainedProperty, exists := properties.Get("chainedRef")
Expand All @@ -140,10 +140,10 @@ func TestSchema_Defs_Success(t *testing.T) {
// Get the resolved schema - should be the final ChainedTarget
result := chainedProperty.GetResolvedSchema()
require.NotNil(t, result)
assert.True(t, result.IsLeft())
assert.True(t, result.IsSchema())

// Verify it's the ChainedTarget schema
resolvedSchema := result.GetLeft()
resolvedSchema := result.GetSchema()
assert.Equal(t, []SchemaType{SchemaTypeObject}, resolvedSchema.GetType())

// Verify it has the expected properties
Expand All @@ -152,13 +152,13 @@ func TestSchema_Defs_Success(t *testing.T) {

valueProperty, exists := resolvedProperties.Get("value")
require.True(t, exists)
assert.True(t, valueProperty.IsLeft())
assert.Equal(t, []SchemaType{SchemaTypeString}, valueProperty.GetLeft().GetType())
assert.True(t, valueProperty.IsSchema())
assert.Equal(t, []SchemaType{SchemaTypeString}, valueProperty.GetSchema().GetType())

descProperty, exists := resolvedProperties.Get("description")
require.True(t, exists)
assert.True(t, descProperty.IsLeft())
assert.Equal(t, []SchemaType{SchemaTypeString}, descProperty.GetLeft().GetType())
assert.True(t, descProperty.IsSchema())
assert.Equal(t, []SchemaType{SchemaTypeString}, descProperty.GetSchema().GetType())
})

t.Run("resolve reference from within nested schema with local $defs", func(t *testing.T) {
Expand All @@ -174,16 +174,16 @@ func TestSchema_Defs_Success(t *testing.T) {

// Navigate to the NestedSchema which has its own $defs
rootSchema := root.MustGetResolvedSchema()
require.True(t, rootSchema.IsLeft())
require.True(t, rootSchema.IsSchema())

nestedSchema, ok := rootSchema.GetLeft().GetDefs().Get("NestedSchema")
nestedSchema, ok := rootSchema.GetSchema().GetDefs().Get("NestedSchema")
require.True(t, ok)

nestedSchemaResolved := nestedSchema.MustGetResolvedSchema()
require.True(t, nestedSchemaResolved.IsLeft())
require.True(t, nestedSchemaResolved.IsSchema())

// Get the localRef property which should reference the local $defs/LocalDef
properties := nestedSchemaResolved.GetLeft().GetProperties()
properties := nestedSchemaResolved.GetSchema().GetProperties()
require.NotNil(t, properties)

localRef, exists := properties.Get("localRef")
Expand All @@ -199,10 +199,10 @@ func TestSchema_Defs_Success(t *testing.T) {
// Get the resolved localRef schema
localRefResolved := localRef.GetResolvedSchema()
require.NotNil(t, localRefResolved)
require.True(t, localRefResolved.IsLeft())
require.True(t, localRefResolved.IsSchema())

// Verify it's the LocalDef schema
resolvedSchema := localRefResolved.GetLeft()
resolvedSchema := localRefResolved.GetSchema()
assert.Equal(t, []SchemaType{SchemaTypeObject}, resolvedSchema.GetType())

// Verify it has the expected properties
Expand All @@ -211,8 +211,8 @@ func TestSchema_Defs_Success(t *testing.T) {

localValueProperty, exists := resolvedProperties.Get("localValue")
require.True(t, exists)
assert.True(t, localValueProperty.IsLeft())
assert.Equal(t, []SchemaType{SchemaTypeString}, localValueProperty.GetLeft().GetType())
assert.True(t, localValueProperty.IsSchema())
assert.Equal(t, []SchemaType{SchemaTypeString}, localValueProperty.GetSchema().GetType())
})

t.Run("$defs getter method works correctly", func(t *testing.T) {
Expand All @@ -222,26 +222,26 @@ func TestSchema_Defs_Success(t *testing.T) {
require.NoError(t, err)

// Get the $defs from the root schema
require.True(t, root.IsLeft())
schema := root.GetLeft()
require.True(t, root.IsSchema())
schema := root.GetSchema()
defs := schema.GetDefs()
require.NotNil(t, defs)

// Verify we have the expected definitions
userDef, exists := defs.Get("User")
require.True(t, exists)
assert.True(t, userDef.IsLeft())
assert.Equal(t, []SchemaType{SchemaTypeObject}, userDef.GetLeft().GetType())
assert.True(t, userDef.IsSchema())
assert.Equal(t, []SchemaType{SchemaTypeObject}, userDef.GetSchema().GetType())

addressDef, exists := defs.Get("Address")
require.True(t, exists)
assert.True(t, addressDef.IsLeft())
assert.Equal(t, []SchemaType{SchemaTypeObject}, addressDef.GetLeft().GetType())
assert.True(t, addressDef.IsSchema())
assert.Equal(t, []SchemaType{SchemaTypeObject}, addressDef.GetSchema().GetType())

nestedDef, exists := defs.Get("NestedSchema")
require.True(t, exists)
assert.True(t, nestedDef.IsLeft())
assert.Equal(t, []SchemaType{SchemaTypeObject}, nestedDef.GetLeft().GetType())
assert.True(t, nestedDef.IsSchema())
assert.Equal(t, []SchemaType{SchemaTypeObject}, nestedDef.GetSchema().GetType())
})
}

Expand All @@ -261,9 +261,9 @@ func TestSchema_Defs_Error(t *testing.T) {

// Navigate to the nonExistentRef property which references a non-existent definition
rootSchema := root.MustGetResolvedSchema()
require.True(t, rootSchema.IsLeft())
require.True(t, rootSchema.IsSchema())

properties := rootSchema.GetLeft().GetProperties()
properties := rootSchema.GetSchema().GetProperties()
require.NotNil(t, properties)

nonExistentProperty, exists := properties.Get("nonExistentRef")
Expand Down Expand Up @@ -358,9 +358,9 @@ func TestSchema_ExternalDefs_Success(t *testing.T) {

// Navigate to the externalUser property which references external $defs
rootSchema := testSchema.MustGetResolvedSchema()
require.True(t, rootSchema.IsLeft())
require.True(t, rootSchema.IsSchema())

properties := rootSchema.GetLeft().GetProperties()
properties := rootSchema.GetSchema().GetProperties()
require.NotNil(t, properties)

externalUserProperty, exists := properties.Get("externalUser")
Expand All @@ -375,10 +375,10 @@ func TestSchema_ExternalDefs_Success(t *testing.T) {
// Get the resolved schema
result := externalUserProperty.GetResolvedSchema()
require.NotNil(t, result, "resolved schema should not be nil")
assert.True(t, result.IsLeft(), "resolved schema should be a schema, not a reference")
assert.True(t, result.IsSchema(), "resolved schema should be a schema, not a reference")

// Verify the resolved schema has the expected structure
resolvedSchema := result.GetLeft()
resolvedSchema := result.GetSchema()
assert.Equal(t, []SchemaType{SchemaTypeObject}, resolvedSchema.GetType(), "resolved schema should be object type")

resolvedProperties := resolvedSchema.GetProperties()
Expand All @@ -387,13 +387,13 @@ func TestSchema_ExternalDefs_Success(t *testing.T) {
// Verify ExternalUser properties
idProperty, exists := resolvedProperties.Get("id")
require.True(t, exists, "resolved schema should have id property")
assert.True(t, idProperty.IsLeft(), "id property should be a schema")
assert.Equal(t, []SchemaType{SchemaTypeInteger}, idProperty.GetLeft().GetType(), "id should be integer type")
assert.True(t, idProperty.IsSchema(), "id property should be a schema")
assert.Equal(t, []SchemaType{SchemaTypeInteger}, idProperty.GetSchema().GetType(), "id should be integer type")

nameProperty, exists := resolvedProperties.Get("name")
require.True(t, exists, "resolved schema should have name property")
assert.True(t, nameProperty.IsLeft(), "name property should be a schema")
assert.Equal(t, []SchemaType{SchemaTypeString}, nameProperty.GetLeft().GetType(), "name should be string type")
assert.True(t, nameProperty.IsSchema(), "name property should be a schema")
assert.Equal(t, []SchemaType{SchemaTypeString}, nameProperty.GetSchema().GetType(), "name should be string type")
})

t.Run("resolve reference to non-existent external $defs", func(t *testing.T) {
Expand Down Expand Up @@ -422,9 +422,9 @@ func TestSchema_ExternalDefs_Success(t *testing.T) {

// Navigate to the nonExistentUser property which references non-existent external $defs
rootSchema := testSchema.MustGetResolvedSchema()
require.True(t, rootSchema.IsLeft())
require.True(t, rootSchema.IsSchema())

properties := rootSchema.GetLeft().GetProperties()
properties := rootSchema.GetSchema().GetProperties()
require.NotNil(t, properties)

nonExistentProperty, exists := properties.Get("nonExistentUser")
Expand Down
20 changes: 10 additions & 10 deletions jsonschema/oas3/inline.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -293,7 +293,7 @@ func analyzeReferences(ctx context.Context, schema *JSONSchema[Referenceable], o
return analyzeReferences(ctx, ConcreteToReferenceable(resolved), opts, refTracker, visited, counter)
}

if resolved.IsRight() {
if resolved.IsBool() {
return nil // Boolean schemas don't have references to analyze
}

Expand All @@ -302,7 +302,7 @@ func analyzeReferences(ctx context.Context, schema *JSONSchema[Referenceable], o
currentFrame = visited[len(visited)-1]
}

js := resolved.GetLeft()
js := resolved.GetSchema()

// Analyze all nested schemas
for _, schema := range js.AllOf {
Expand Down Expand Up @@ -445,7 +445,7 @@ func inlineRecursive(ctx context.Context, schema *JSONSchema[Referenceable], opt
// This is the second+ occurrence of a circular reference
// Rewrite the reference if needed, then don't recurse
if info.rewrittenRef != "" {
schema.GetLeft().Ref = pointer.From(references.Reference(info.rewrittenRef))
schema.GetSchema().Ref = pointer.From(references.Reference(info.rewrittenRef))
rewrittenAbsRef := references.Reference(opts.ResolveOptions.TargetLocation + info.rewrittenRef)
// Add reverse lookup for the rewritten reference
if !refTracker.Has(rewrittenAbsRef.String()) {
Expand All @@ -459,12 +459,12 @@ func inlineRecursive(ctx context.Context, schema *JSONSchema[Referenceable], opt
}
// If not preserve, this reference should be inlined - we'll process its content below
}
if resolved.IsRight() {
if resolved.IsBool() {
inlineSchemaInPlace(schema, resolved)
return schema, nil
}

js := resolved.GetLeft()
js := resolved.GetSchema()

// Walk through allOf schemas
for i, s := range js.AllOf {
Expand Down Expand Up @@ -613,7 +613,7 @@ func inlineRecursive(ctx context.Context, schema *JSONSchema[Referenceable], opt
inlineSchemaInPlace(schema, resolved)
} else if info.rewrittenRef != "" {
// This is a preserved reference - rewrite it to point to the new $defs location
schema.GetLeft().Ref = pointer.From(references.Reference(info.rewrittenRef))
schema.GetSchema().Ref = pointer.From(references.Reference(info.rewrittenRef))
rewrittenAbsRef := references.Reference(opts.ResolveOptions.TargetLocation + info.rewrittenRef)
// Add reverse lookup for the rewritten reference
if !refTracker.Has(rewrittenAbsRef.String()) {
Expand Down Expand Up @@ -662,11 +662,11 @@ func inlineSchemaInPlace(schema *JSONSchema[Referenceable], resolved *JSONSchema

// removeUnusedDefs removes $defs that are no longer referenced after inlining
func removeUnusedDefs(_ context.Context, schema *JSONSchema[Referenceable], refTracker *sequencedmap.Map[string, *refInfo]) {
if schema == nil || !schema.IsLeft() {
if schema == nil || !schema.IsSchema() {
return
}

schemaObj := schema.GetLeft()
schemaObj := schema.GetSchema()
if schemaObj == nil || schemaObj.Defs == nil || schemaObj.Defs.Len() == 0 {
return
}
Expand Down Expand Up @@ -802,11 +802,11 @@ func consolidateDefinitions(schema *JSONSchema[Referenceable], refTracker *seque
}

// Ensure we have a schema object (not a boolean schema)
if schema.IsRight() {
if schema.IsBool() {
return errors.New("cannot add definitions to a boolean schema")
}

js := schema.GetLeft()
js := schema.GetSchema()
if js == nil {
return errors.New("schema object is nil")
}
Expand Down
Loading