fix absolute ref resolution behavior

Signed-off-by: Morgan Chang <shin19991207@gmail.com>

Author: shin19991207

src/languageservice/services/yamlSchemaService.ts

@@ -499,6 +499,34 @@ export class YAMLSchemaService extends JSONSchemaService {
       }
     };
 
+    const _resolveRefUri = (parentSchemaURL: string, refUri: string): string => {
+      const resolvedAgainstParent = _resolveAgainstBase(parentSchemaURL, refUri);
+      if (!refUri.startsWith('/')) return resolvedAgainstParent;
+      const parentResource = resourceIndexByUri.get(parentSchemaURL)?.root;
+      const parentResourceId = parentResource?.$id || parentResource?.id;
+      const resolvedParentId = _resolveAgainstBase(parentSchemaURL, parentResourceId);
+      if (!resolvedParentId.startsWith('http://') && !resolvedParentId.startsWith('https://')) return resolvedAgainstParent;
+
+      return _resolveAgainstBase(resolvedParentId, refUri);
+    };
+
+    const _resolveLocalSiblingFromRemoteUri = (parentSchemaURL: string, resolvedRefUri: string): string | undefined => {
+      try {
+        const parentUri = URI.parse(parentSchemaURL);
+        const targetUri = URI.parse(resolvedRefUri);
+        if (parentUri.scheme !== 'file') return undefined;
+        if (targetUri.scheme !== 'http' && targetUri.scheme !== 'https') return undefined;
+
+        const localFileName = path.posix.basename(targetUri.path);
+        if (!localFileName) return undefined;
+        const localDir = path.posix.dirname(parentUri.path);
+        const localPath = path.posix.join(localDir, localFileName);
+        return parentUri.with({ path: localPath, query: targetUri.query, fragment: targetUri.fragment }).toString();
+      } catch {
+        return undefined;
+      }
+    };
+
     const resolveExternalLink = (
       node: JSONSchema,
       uri: string,
@@ -541,42 +569,57 @@ export class YAMLSchemaService extends JSONSchemaService {
         );
       };
 
-      const resolvedUri = _resolveAgainstBase(parentSchemaURL, uri);
-      const embeddedSchema = resourceIndexByUri.get(resolvedUri)?.root;
-      if (embeddedSchema) {
-        return _attachResolvedSchema(
-          node,
-          embeddedSchema,
-          resolvedUri,
-          linkPath,
-          parentSchemaDependencies,
-          parentSchemaDependencies,
-          resolutionStack,
-          recursiveAnchorBase,
-          inheritedDynamicScope
-        );
-      }
+      const _resolveByUri = (targetUris: string[], index = 0): Promise<unknown> => {
+        const targetUri = targetUris[index];
 
-      const referencedHandle = this.getOrAddSchemaHandle(resolvedUri);
-      return referencedHandle.getUnresolvedSchema().then(async (unresolvedSchema) => {
-        if (unresolvedSchema.errors.length) {
-          const loc = linkPath ? resolvedUri + '#' + linkPath : resolvedUri;
-          resolveErrors.push(l10n.t("Problems loading reference '{0}': {1}", loc, unresolvedSchema.errors[0]));
+        const embeddedSchema = resourceIndexByUri.get(targetUri)?.root;
+        if (embeddedSchema) {
+          return _attachResolvedSchema(
+            node,
+            embeddedSchema,
+            targetUri,
+            linkPath,
+            parentSchemaDependencies,
+            parentSchemaDependencies,
+            resolutionStack,
+            recursiveAnchorBase,
+            inheritedDynamicScope
+          );
         }
-        // index resources for the newly loaded schema
-        await _indexSchemaResources(unresolvedSchema.schema, resolvedUri);
-        return _attachResolvedSchema(
-          node,
-          unresolvedSchema.schema,
-          resolvedUri,
-          linkPath,
-          parentSchemaDependencies,
-          referencedHandle.dependencies,
-          resolutionStack,
-          recursiveAnchorBase,
-          inheritedDynamicScope
-        );
-      });
+
+        const referencedHandle = this.getOrAddSchemaHandle(targetUri);
+        return referencedHandle.getUnresolvedSchema().then(async (unresolvedSchema) => {
+          if (
+            unresolvedSchema.errors?.some((error) => error.toLowerCase().includes('unable to load schema from')) &&
+            index + 1 < targetUris.length
+          ) {
+            return _resolveByUri(targetUris, index + 1);
+          }
+
+          if (unresolvedSchema.errors.length) {
+            const loc = linkPath ? targetUri + '#' + linkPath : targetUri;
+            resolveErrors.push(l10n.t("Problems loading reference '{0}': {1}", loc, unresolvedSchema.errors[0]));
+          }
+          // index resources for the newly loaded schema
+          await _indexSchemaResources(unresolvedSchema.schema, targetUri);
+          return _attachResolvedSchema(
+            node,
+            unresolvedSchema.schema,
+            targetUri,
+            linkPath,
+            parentSchemaDependencies,
+            referencedHandle.dependencies,
+            resolutionStack,
+            recursiveAnchorBase,
+            inheritedDynamicScope
+          );
+        });
+      };
+
+      const resolvedUri = _resolveRefUri(parentSchemaURL, uri);
+      const localSiblingUri = _resolveLocalSiblingFromRemoteUri(parentSchemaURL, resolvedUri);
+      const targetUris = localSiblingUri && localSiblingUri !== resolvedUri ? [localSiblingUri, resolvedUri] : [resolvedUri];
+      return _resolveByUri(targetUris);
     };
 
     const resolveRefs = async (

test/yamlSchemaService.test.ts

@@ -164,7 +164,7 @@ describe('YAML Schema Service', () => {
       expect(requestedUris).to.not.include('https://example.com/schemas/secondary.json');
     });
 
-    it('should use local schema path for absolute $ref before remote $id ref', async () => {
+    it('should resolve absolute $ref via remote base and mapped local sibling path', async () => {
       const content = `# yaml-language-server: $schema=file:///dir/primary.json\nname: John\nage: -1`;
       const yamlDock = parse(content);
 
@@ -186,7 +186,7 @@ describe('YAML Schema Service', () => {
         if (uri === 'file:///dir/primary.json') {
           return Promise.resolve(JSON.stringify(primarySchema));
         }
-        if (uri === 'file:///schemas/secondary.json') {
+        if (uri === 'file:///dir/secondary.json') {
           return Promise.resolve(JSON.stringify(secondarySchema));
         }
         return Promise.reject<string>(`Resource ${uri} not found.`);
@@ -197,10 +197,52 @@ describe('YAML Schema Service', () => {
 
       const requestedUris = requestServiceMock.getCalls().map((call) => call.args[0]);
       expect(requestedUris).to.include('file:///dir/primary.json');
-      expect(requestedUris).to.include('file:///schemas/secondary.json');
+      expect(requestedUris).to.include('file:///dir/secondary.json');
+      expect(requestedUris).to.not.include('file:///schemas/secondary.json');
       expect(requestedUris).to.not.include('https://example.com/schemas/secondary.json');
     });
 
+    it('should fallback to remote $id target for absolute $ref when mapped local target is missing', async () => {
+      const content = `# yaml-language-server: $schema=file:///dir/primary.json\nname: John\nage: -1`;
+      const yamlDock = parse(content);
+
+      const primarySchema = {
+        $id: 'https://example.com/schemas/primary.json',
+        $ref: '/schemas/secondary.json',
+      };
+      const secondarySchema = {
+        $id: 'https://example.com/schemas/secondary.json',
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          age: { type: 'integer', minimum: 0 },
+        },
+        required: ['name', 'age'],
+      };
+
+      requestServiceMock = sandbox.fake((uri: string) => {
+        if (uri === 'file:///dir/primary.json') {
+          return Promise.resolve(JSON.stringify(primarySchema));
+        }
+        if (uri === 'https://example.com/schemas/secondary.json') {
+          return Promise.resolve(JSON.stringify(secondarySchema));
+        }
+        return Promise.reject<string>(`Resource ${uri} not found.`);
+      });
+
+      const service = new SchemaService.YAMLSchemaService(requestServiceMock, workspaceContext);
+      await service.getSchemaForResource('', yamlDock.documents[0]);
+
+      const requestedUris = requestServiceMock.getCalls().map((call) => call.args[0]);
+      expect(requestedUris).to.include('file:///dir/primary.json');
+      expect(requestedUris).to.include('file:///dir/secondary.json');
+      expect(requestedUris).to.include('https://example.com/schemas/secondary.json');
+      expect(requestedUris).to.not.include('file:///schemas/secondary.json');
+      expect(requestedUris.indexOf('file:///dir/secondary.json')).to.be.lessThan(
+        requestedUris.indexOf('https://example.com/schemas/secondary.json')
+      );
+    });
+
     it('should reload local schema after local file change when resolving via local sibling path instead of remote $id', async () => {
       const content = `# yaml-language-server: $schema=file:///schemas/primary.json\nmode: stage`;
       const yamlDock = parse(content);