fix: recursive resolution of bundled and inlined documents and handling of number based jsonpointer parts (#35)

Author: TristanSpeakEasy

jsonpointer/jsonpointer.go

@@ -149,9 +149,6 @@ func getMapTarget(sourceVal reflect.Value, currentPart navigationPart, stack []n
 	sourceValElem := reflect.Indirect(sourceVal)
 
 	// Allow both partTypeKey and partTypeIndex for maps (integer keys should be treated as string keys)
-	if currentPart.Type != partTypeKey && currentPart.Type != partTypeIndex {
-		return nil, nil, ErrInvalidPath.Wrap(fmt.Errorf("expected key or index, got %s at %s", currentPart.Type, currentPath))
-	}
 	if sourceValElem.IsNil() {
 		return nil, nil, ErrNotFound.Wrap(fmt.Errorf("map is nil at %s", currentPath))
 	}

jsonpointer/jsonpointer_test.go

@@ -291,6 +291,14 @@ func TestGetTarget_Success(t *testing.T) {
 			},
 			want: "value",
 		},
+		{
+			name: "numeric string as key in map",
+			args: args{
+				source:  map[string]any{"400": "Bad Request", "200": "OK"},
+				pointer: JSONPointer("/400"),
+			},
+			want: "Bad Request",
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

jsonpointer/models.go

@@ -15,9 +15,6 @@ type model interface {
 
 func navigateModel(sourceVal reflect.Value, currentPart navigationPart, stack []navigationPart, currentPath string, o *options) (any, []navigationPart, error) {
 	// Models support both key-based and index-based navigation (treat index as key)
-	if currentPart.Type != partTypeKey && currentPart.Type != partTypeIndex {
-		return nil, nil, ErrInvalidPath.Wrap(fmt.Errorf("models only support key or index navigation, got %s at %s", currentPart.Type, currentPath))
-	}
 
 	// Ensure we have a model interface
 	if !sourceVal.CanInterface() {

jsonpointer/yamlnode.go

@@ -58,10 +58,6 @@ func getYamlDocumentTarget(node *yaml.Node, currentPart navigationPart, stack []
 }
 
 func getYamlMappingTarget(node *yaml.Node, currentPart navigationPart, stack []navigationPart, currentPath string, o *options) (any, []navigationPart, error) {
-	if currentPart.Type != partTypeKey {
-		return nil, nil, ErrInvalidPath.Wrap(fmt.Errorf("expected key, got %s at %s", currentPart.Type, currentPath))
-	}
-
 	key := currentPart.unescapeValue()
 
 	// YAML mapping nodes have content in pairs: [key1, value1, key2, value2, ...]

jsonpointer/yamlnode_test.go

@@ -129,6 +129,44 @@ api:
 				assert.Equal(t, "Get user", node.Value)
 			},
 		},
+		{
+			name: "numeric string as key in yaml mapping",
+			args: args{
+				yamlContent: `responses:
+  "200": "OK"
+  "400": "Bad Request"
+  "500": "Internal Server Error"`,
+				pointer: JSONPointer("/responses/400"),
+			},
+			validate: func(t *testing.T, result any) {
+				t.Helper()
+				node, ok := result.(*yaml.Node)
+				require.True(t, ok, "result should be *yaml.Node")
+				assert.Equal(t, yaml.ScalarNode, node.Kind)
+				assert.Equal(t, "Bad Request", node.Value)
+			},
+		},
+		{
+			name: "numeric string as key in nested yaml mapping",
+			args: args{
+				yamlContent: `components:
+  responses:
+    "400":
+      description: "Bad Request"
+      content:
+        application/json:
+          schema:
+            type: object`,
+				pointer: JSONPointer("/components/responses/400/description"),
+			},
+			validate: func(t *testing.T, result any) {
+				t.Helper()
+				node, ok := result.(*yaml.Node)
+				require.True(t, ok, "result should be *yaml.Node")
+				assert.Equal(t, yaml.ScalarNode, node.Kind)
+				assert.Equal(t, "Bad Request", node.Value)
+			},
+		},
 	}
 
 	for _, tt := range tests {
@@ -181,12 +219,12 @@ func TestGetTarget_YamlNode_Error(t *testing.T) {
 			wantErr: "not found -- index 5 out of range for yaml sequence of length 3 at /items/5",
 		},
 		{
-			name: "wrong type - using index on mapping",
+			name: "numeric key not found in mapping",
 			args: args{
 				yamlContent: `name: test`,
 				pointer:     JSONPointer("/0"),
 			},
-			wantErr: "invalid path -- expected key, got index at /0",
+			wantErr: "not found -- key 0 not found in yaml mapping at /0",
 		},
 		{
 			name: "wrong type - using key on sequence",

jsonschema/oas3/resolution.go

@@ -59,10 +59,15 @@ func (j *JSONSchema[Referenceable]) GetAbsRef() references.Reference {
 // Validation errors can be skipped by setting the skipValidation flag to true. This will skip the missing field errors that occur during unmarshaling.
 // Resolution doesn't run the Validate function on the resolved object. So if you want to fully validate the object after resolution, you need to call the Validate function manually.
 func (s *JSONSchema[Referenceable]) Resolve(ctx context.Context, opts ResolveOptions) ([]error, error) {
+	targetDocument := opts.TargetDocument
+	if targetDocument == nil {
+		targetDocument = opts.RootDocument
+	}
+
 	return resolveJSONSchemaWithTracking(ctx, (*JSONSchemaReferenceable)(unsafe.Pointer(s)), references.ResolveOptions{ //nolint:gosec
 		TargetLocation:      opts.TargetLocation,
 		RootDocument:        opts.RootDocument,
-		TargetDocument:      opts.RootDocument,
+		TargetDocument:      targetDocument,
 		DisableExternalRefs: opts.DisableExternalRefs,
 		VirtualFS:           opts.VirtualFS,
 		HTTPClient:          opts.HTTPClient,
@@ -121,6 +126,22 @@ func (s *JSONSchema[Referenceable]) MustGetResolvedSchema() *JSONSchema[Concrete
 	return obj
 }
 
+func (r *JSONSchema[Referenceable]) GetReferenceResolutionInfo() *references.ResolveResult[JSONSchemaReferenceable] {
+	if r == nil {
+		return nil
+	}
+
+	if !r.IsReference() {
+		return nil
+	}
+
+	if r.referenceResolutionCache == nil {
+		return nil
+	}
+
+	return r.referenceResolutionCache
+}
+
 func (s *JSONSchema[Referenceable]) resolve(ctx context.Context, opts references.ResolveOptions, referenceChain []string) ([]string, []error, error) {
 	if !s.IsReference() {
 		return referenceChain, nil, nil