@platformos/platformos-language-server-common 0.0.12 → 0.0.13

package/src/documentLinks/DocumentLinksProvider.spec.ts

@@ -3,28 +3,35 @@ import { DocumentManager } from '../documents';
 import { DocumentLinksProvider } from './DocumentLinksProvider';
 import { DocumentsLocator, TranslationProvider } from '@platformos/platformos-common';
 import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
+import { SearchPathsLoader } from '../utils/searchPaths';
+
+function makeProvider(
+  documentManager: DocumentManager,
+  rootUri: string,
+  mockFs: MockFileSystem,
+): DocumentLinksProvider {
+  return new DocumentLinksProvider(
+    documentManager,
+    async () => rootUri,
+    new DocumentsLocator(mockFs),
+    new TranslationProvider(mockFs),
+    new SearchPathsLoader(mockFs),
+  );
+}
 
 describe('DocumentLinksProvider', () => {
   let documentManager: DocumentManager;
   let documentLinksProvider: DocumentLinksProvider;
-  let documentsLocator: DocumentsLocator;
-  let fs: MockFileSystem;
   let rootUri: string;
   let uriString: string;
 
   beforeEach(() => {
     documentManager = new DocumentManager();
-    fs = new MockFileSystem({
+    const fs = new MockFileSystem({
       'path/to/project/app/lib/commands/apply.liquid': 'apply content',
       'path/to/project/app/views/apply_view.liquid': 'apply view content',
     });
-    documentsLocator = new DocumentsLocator(fs);
-    documentLinksProvider = new DocumentLinksProvider(
-      documentManager,
-      async () => rootUri,
-      documentsLocator,
-      new TranslationProvider(fs),
-    );
+    documentLinksProvider = makeProvider(documentManager, 'file:///path/to/project', fs);
   });
 
   it('should return an empty array for non-LiquidHtml documents', async () => {
@@ -63,4 +70,118 @@ describe('DocumentLinksProvider', () => {
       expect(result[i].target).toBe(expectedUrls[i]);
     }
   });
+
+  describe('theme_render_rc', () => {
+    it('should resolve theme_render_rc partials via theme_search_paths', async () => {
+      rootUri = 'file:///project';
+      uriString = 'file:///project/app/views/pages/index.liquid';
+
+      const mockFs = new MockFileSystem({
+        'project/app/config.yml': 'theme_search_paths:\n  - theme/dress\n  - theme/simple',
+        'project/app/views/partials/theme/dress/card.liquid': 'dress card',
+        'project/app/views/partials/theme/simple/footer.liquid': 'simple footer',
+      });
+
+      const provider = makeProvider(documentManager, rootUri, mockFs);
+
+      documentManager.open(
+        uriString,
+        "{% theme_render_rc 'card' %} {% theme_render_rc 'footer' %}",
+        1,
+      );
+
+      const result = await provider.documentLinks(uriString);
+
+      expect(result).toHaveLength(2);
+      expect(result[0].target).toBe('file:///project/app/views/partials/theme/dress/card.liquid');
+      expect(result[1].target).toBe(
+        'file:///project/app/views/partials/theme/simple/footer.liquid',
+      );
+    });
+
+    it('should fallback to standard resolution when no config exists', async () => {
+      rootUri = 'file:///project';
+      uriString = 'file:///project/app/views/pages/index.liquid';
+
+      const mockFs = new MockFileSystem({
+        'project/app/views/partials/card.liquid': 'default card',
+      });
+
+      const provider = makeProvider(documentManager, rootUri, mockFs);
+
+      documentManager.open(uriString, "{% theme_render_rc 'card' %}", 1);
+
+      const result = await provider.documentLinks(uriString);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].target).toBe('file:///project/app/views/partials/card.liquid');
+    });
+
+    it('should resolve theme_render_rc with Liquid wildcard paths', async () => {
+      rootUri = 'file:///project';
+      uriString = 'file:///project/app/views/pages/index.liquid';
+
+      const mockFs = new MockFileSystem({
+        'project/app/config.yml': 'theme_search_paths:\n  - theme/{{ context.constants.THEME }}',
+        'project/app/views/partials/theme/custom/hero.liquid': 'custom hero',
+      });
+
+      const provider = makeProvider(documentManager, rootUri, mockFs);
+
+      documentManager.open(uriString, "{% theme_render_rc 'hero' %}", 1);
+
+      const result = await provider.documentLinks(uriString);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].target).toBe('file:///project/app/views/partials/theme/custom/hero.liquid');
+    });
+
+    it('should not use search paths for regular render tags', async () => {
+      rootUri = 'file:///project';
+      uriString = 'file:///project/app/views/pages/index.liquid';
+
+      const mockFs = new MockFileSystem({
+        'project/app/config.yml': 'theme_search_paths:\n  - theme/dress',
+        'project/app/views/partials/card.liquid': 'default card',
+      });
+
+      const provider = makeProvider(documentManager, rootUri, mockFs);
+
+      documentManager.open(uriString, "{% render 'card' %}", 1);
+
+      const result = await provider.documentLinks(uriString);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].target).toBe('file:///project/app/views/partials/card.liquid');
+    });
+
+    it('should pick up new config after cache invalidation', async () => {
+      rootUri = 'file:///project';
+      uriString = 'file:///project/app/views/pages/index.liquid';
+
+      const initialFiles: Record<string, string> = {
+        'project/app/views/partials/card.liquid': 'default card',
+        'project/app/views/partials/theme/new/card.liquid': 'new card',
+      };
+      const mockFs = new MockFileSystem(initialFiles);
+      const provider = makeProvider(documentManager, rootUri, mockFs);
+
+      documentManager.open(uriString, "{% theme_render_rc 'card' %}", 1);
+
+      const result1 = await provider.documentLinks(uriString);
+      expect(result1).toHaveLength(1);
+      expect(result1[0].target).toBe('file:///project/app/views/partials/card.liquid');
+
+      // Simulate config.yml being created with search paths — new provider with new fs
+      const updatedFs = new MockFileSystem({
+        ...initialFiles,
+        'project/app/config.yml': 'theme_search_paths:\n  - theme/new',
+      });
+      const provider2 = makeProvider(documentManager, rootUri, updatedFs);
+
+      const result2 = await provider2.documentLinks(uriString);
+      expect(result2).toHaveLength(1);
+      expect(result2[0].target).toBe('file:///project/app/views/partials/theme/new/card.liquid');
+    });
+  });
 });

package/src/documentLinks/DocumentLinksProvider.ts

@@ -1,13 +1,14 @@
-import { LiquidHtmlNode, LiquidString, NamedTags, NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidHtmlNode, LiquidString, NodeTypes } from '@platformos/liquid-html-parser';
 import { SourceCodeType } from '@platformos/platformos-check-common';
 import { DocumentLink, Range } from 'vscode-languageserver';
 import { TextDocument } from 'vscode-languageserver-textdocument';
-import { URI, Utils } from 'vscode-uri';
+import { URI } from 'vscode-uri';
 
 import { visit, Visitor } from '@platformos/platformos-check-common';
 import { DocumentManager } from '../documents';
 import { FindAppRootURI } from '../internal-types';
-import { DocumentsLocator, TranslationProvider } from '@platformos/platformos-common';
+import { DocumentsLocator, DocumentType, TranslationProvider } from '@platformos/platformos-common';
+import { SearchPathsLoader } from '../utils/searchPaths';
 
 export class DocumentLinksProvider {
   constructor(
@@ -15,6 +16,7 @@ export class DocumentLinksProvider {
     private findAppRootURI: FindAppRootURI,
     private documentsLocator: DocumentsLocator,
     private translationProvider: TranslationProvider,
+    private searchPathsCache: SearchPathsLoader,
   ) {}
 
   async documentLinks(uriString: string): Promise<DocumentLink[]> {
@@ -32,11 +34,15 @@ export class DocumentLinksProvider {
       return [];
     }
 
+    const root = URI.parse(rootUri);
+    const searchPaths = await this.searchPathsCache.get(root);
+
     const visitor = documentLinksVisitor(
       sourceCode.textDocument,
-      URI.parse(rootUri),
+      root,
       this.documentsLocator,
       this.translationProvider,
+      searchPaths,
     );
     return visit(sourceCode.ast, visitor);
   }
@@ -47,43 +53,28 @@ function documentLinksVisitor(
   root: URI,
   documentsLocator: DocumentsLocator,
   translationProvider: TranslationProvider,
+  searchPaths: string[] | null,
 ): Visitor<SourceCodeType.LiquidHtml, DocumentLink> {
   return {
     async LiquidTag(node) {
-      if (
-        (node.name === 'render' || node.name === 'include') &&
-        typeof node.markup !== 'string' &&
-        isLiquidString(node.markup.partial)
-      ) {
-        const partial = node.markup.partial;
-        return DocumentLink.create(
-          range(textDocument, partial),
-          await documentsLocator.locate(root, node.name, partial.value),
-        );
-      }
+      const markup = node.markup;
+      if (typeof markup === 'string' || markup === null) return;
+
+      const name = node.name as DocumentType;
 
-      if (
-        node.name === 'function' &&
-        typeof node.markup !== 'string' &&
-        isLiquidString(node.markup.partial)
-      ) {
-        const partial = node.markup.partial;
+      // render, include, function, theme_render_rc all have a .partial field
+      if ('partial' in markup && isLiquidString(markup.partial)) {
         return DocumentLink.create(
-          range(textDocument, partial),
-          await documentsLocator.locate(root, node.name, partial.value),
+          range(textDocument, markup.partial),
+          await documentsLocator.locate(root, name, markup.partial.value, searchPaths),
         );
       }
 
-      if (
-        node.name === 'graphql' &&
-        typeof node.markup !== 'string' &&
-        'graphql' in node.markup &&
-        isLiquidString(node.markup.graphql)
-      ) {
-        const snippet = node.markup.graphql;
+      // graphql has a .graphql field
+      if ('graphql' in markup && isLiquidString(markup.graphql)) {
         return DocumentLink.create(
-          range(textDocument, snippet),
-          await documentsLocator.locate(root, node.name, snippet.value),
+          range(textDocument, markup.graphql),
+          await documentsLocator.locate(root, name, markup.graphql.value),
         );
       }
     },

package/src/hover/HoverProvider.ts

@@ -23,10 +23,12 @@ import {
 import { HtmlAttributeValueHoverProvider } from './providers/HtmlAttributeValueHoverProvider';
 import { findCurrentNode } from '@platformos/platformos-check-common';
 import { LiquidDocTagHoverProvider } from './providers/LiquidDocTagHoverProvider';
+import { GraphQLFieldHoverProvider } from './providers/GraphQLFieldHoverProvider';
 import { TranslationProvider } from '@platformos/platformos-common';
 import { FindAppRootURI } from '../../src/internal-types';
 export class HoverProvider {
   private providers: BaseHoverProvider[] = [];
+  private graphqlFieldHoverProvider: GraphQLFieldHoverProvider;
 
   constructor(
     readonly documentManager: DocumentManager,
@@ -37,6 +39,10 @@ export class HoverProvider {
     readonly findAppRootURI: FindAppRootURI = async () => null,
   ) {
     const typeSystem = new TypeSystem(platformosDocset);
+    this.graphqlFieldHoverProvider = new GraphQLFieldHoverProvider(
+      platformosDocset,
+      documentManager,
+    );
     this.providers = [
       new LiquidTagHoverProvider(platformosDocset),
       new LiquidFilterArgumentHoverProvider(platformosDocset),
@@ -57,6 +63,11 @@ export class HoverProvider {
     const uri = params.textDocument.uri;
     const document = this.documentManager.get(uri);
 
+    // GraphQL files get dedicated hover support
+    if (document?.type === SourceCodeType.GraphQL) {
+      return this.graphqlFieldHoverProvider.hover(params);
+    }
+
     // Supports only Liquid resources
     if (document?.type !== SourceCodeType.LiquidHtml || document.ast instanceof Error) {
       return null;

package/src/hover/providers/GraphQLFieldHoverProvider.spec.ts

@@ -0,0 +1,124 @@
+import { describe, beforeEach, it, expect } from 'vitest';
+import { DocumentManager } from '../../documents';
+import { HoverProvider } from '../HoverProvider';
+import { TranslationProvider } from '@platformos/platformos-common';
+import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
+import { HoverParams } from 'vscode-languageserver';
+
+const SCHEMA = `
+type Query {
+  records: RecordList
+  user(id: ID!): User
+}
+
+type RecordList {
+  results: [Record]
+  total_entries: Int
+}
+
+type Record {
+  id: ID
+  name: String
+  email: String
+}
+
+type User {
+  id: ID
+  name: String
+}
+`;
+
+describe('Module: GraphQLFieldHoverProvider', () => {
+  let provider: HoverProvider;
+  let documentManager: DocumentManager;
+
+  beforeEach(() => {
+    documentManager = new DocumentManager();
+    provider = new HoverProvider(
+      documentManager,
+      {
+        graphQL: async () => SCHEMA,
+        filters: async () => [],
+        objects: async () => [],
+        liquidDrops: async () => [],
+        tags: async () => [],
+      },
+      new TranslationProvider(new MockFileSystem({})),
+    );
+  });
+
+  it('should return hover info for a top-level field in a .graphql file', async () => {
+    const source = '{\n  records {\n    total_entries\n  }\n}';
+    const uri = 'file:///app/graphql/test.graphql';
+    documentManager.open(uri, source, 0);
+
+    const params: HoverParams = {
+      position: { line: 1, character: 5 },
+      textDocument: { uri },
+    };
+
+    const result = await provider.hover(params);
+    expect(result).not.toBeNull();
+    expect((result!.contents as any).value).toContain('records');
+    expect((result!.contents as any).value).toContain('RecordList');
+  });
+
+  it('should return hover info for a nested field', async () => {
+    const source = 'query {\n  records {\n    results {\n      name\n    }\n  }\n}';
+    const uri = 'file:///app/graphql/nested.graphql';
+    documentManager.open(uri, source, 0);
+
+    const params: HoverParams = {
+      position: { line: 3, character: 8 },
+      textDocument: { uri },
+    };
+
+    const result = await provider.hover(params);
+    expect(result).not.toBeNull();
+    expect((result!.contents as any).value).toContain('Record.name');
+    expect((result!.contents as any).value).toContain('String');
+  });
+
+  it('should return null when no schema is available', async () => {
+    const noSchemaProvider = new HoverProvider(
+      documentManager,
+      {
+        graphQL: async () => null,
+        filters: async () => [],
+        objects: async () => [],
+        liquidDrops: async () => [],
+        tags: async () => [],
+      },
+      new TranslationProvider(new MockFileSystem({})),
+    );
+
+    const source = 'query {\n  records {\n    results {\n      name\n    }\n  }\n}';
+    const uri = 'file:///app/graphql/test.graphql';
+    documentManager.open(uri, source, 0);
+
+    const params: HoverParams = {
+      position: { line: 1, character: 5 },
+      textDocument: { uri },
+    };
+
+    const result = await noSchemaProvider.hover(params);
+    expect(result).toBeNull();
+  });
+
+  it('should not interfere with .liquid file hover', async () => {
+    const source = '{{ product }}';
+    const uri = 'file:///app/views/partials/test.liquid';
+    documentManager.open(uri, source, 0);
+
+    const textDocument = documentManager.get(uri)!.textDocument;
+    const params: HoverParams = {
+      position: textDocument.positionAt(source.indexOf('product')),
+      textDocument: { uri },
+    };
+
+    // Should not crash — goes through normal Liquid pipeline
+    const result = await provider.hover(params);
+    // product is not in the docset, so hover returns null
+    expect(result).toBeNull();
+  });
+});

package/src/hover/providers/GraphQLFieldHoverProvider.ts

@@ -0,0 +1,90 @@
+import { Hover, HoverParams } from 'vscode-languageserver';
+import { DocumentManager } from '../../documents';
+import { PlatformOSDocset } from '@platformos/platformos-check-common';
+
+/**
+ * graphql-language-service and graphql must be loaded dynamically to avoid
+ * the "Cannot use GraphQLList from another module or realm" error that occurs
+ * when vitest transforms the graphql ESM module into separate instances.
+ * By requiring at runtime, we ensure a single shared module instance.
+ */
+let _glsMod: typeof import('graphql-language-service') | undefined;
+function getGLS(): typeof import('graphql-language-service') {
+  if (!_glsMod) _glsMod = require('graphql-language-service');
+  return _glsMod!;
+}
+
+let _graphqlMod: typeof import('graphql') | undefined;
+function getGraphQL(): typeof import('graphql') {
+  if (!_graphqlMod) _graphqlMod = require('graphql');
+  return _graphqlMod!;
+}
+
+export class GraphQLFieldHoverProvider {
+  private schemaCache: any;
+  private schemaLoaded = false;
+
+  constructor(
+    private platformosDocset: PlatformOSDocset,
+    private documentManager: DocumentManager,
+  ) {}
+
+  private async getSchema(): Promise<any> {
+    if (!this.schemaLoaded) {
+      const sdl = await this.platformosDocset.graphQL();
+      if (sdl) {
+        try {
+          this.schemaCache = getGraphQL().buildSchema(sdl);
+        } catch {
+          // Invalid schema SDL
+        }
+      }
+      this.schemaLoaded = true;
+    }
+    return this.schemaCache;
+  }
+
+  async hover(params: HoverParams): Promise<Hover | null> {
+    const uri = params.textDocument.uri;
+    const document = this.documentManager.get(uri);
+    if (!document) return null;
+
+    const schema = await this.getSchema();
+    if (!schema) return null;
+
+    const content = document.textDocument.getText();
+    const gls = getGLS();
+
+    // graphql-language-service's getHoverInformation uses the character *before* the cursor
+    // position to identify the token. We try offset +1 first, then the original position,
+    // to handle the case where the cursor is at the start of a token.
+    const positions = [
+      new gls.Position(params.position.line, params.position.character + 1),
+      new gls.Position(params.position.line, params.position.character),
+    ];
+
+    try {
+      let hoverInfo: string | undefined;
+      for (const position of positions) {
+        const info = gls.getHoverInformation(schema, content, position);
+        if (info && info !== '' && info !== 'null') {
+          hoverInfo = typeof info === 'string' ? info : String(info);
+          break;
+        }
+      }
+
+      if (!hoverInfo) {
+        return null;
+      }
+
+      return {
+        contents: {
+          kind: 'markdown',
+          value: hoverInfo,
+        },
+      };
+    } catch {
+      return null;
+    }
+  }
+}

package/src/server/AppGraphManager.ts

@@ -23,7 +23,6 @@ import { FindAppRootURI } from '../internal-types';
 
 export class AppGraphManager {
   graphs: Map<string, ReturnType<typeof buildAppGraph>> = new Map();
-
   constructor(
     private connection: Connection,
     private documentManager: DocumentManager,
@@ -153,9 +152,7 @@ export class AppGraphManager {
     const rootUri = await this.findAppRootURI(anyUri);
     if (!rootUri) return;
 
-    const graph = await this.graphs.get(rootUri);
-    if (!graph) return;
-
+    // Delete existing graph to force rebuild
     this.graphs.delete(rootUri);
     await this.getAppGraphForURI(rootUri);
     this.connection.sendNotification(AppGraphDidUpdateNotification.type, { uri: rootUri });
@@ -166,7 +163,8 @@ export class AppGraphManager {
     await documentManager.preload(rootUri);
 
     const dependencies = await this.graphDependencies(rootUri);
-    return buildAppGraph(rootUri, dependencies, entryPoints);
+    const graph = await buildAppGraph(rootUri, dependencies, entryPoints);
+    return graph;
   };
 
   private getSourceCode = async (uri: string) => {

package/src/server/CachedFileSystem.ts

@@ -6,7 +6,12 @@ export class CachedFileSystem implements AbstractFileSystem {
   stat: Cached<AbstractFileSystem['stat']>;
 
   constructor(fs: AbstractFileSystem) {
-    this.readFile = cachedByUri(fs.readFile.bind(fs));
+    this.readFile = cachedByUri(
+      fs.readFile.bind(fs),
+      // app/config.yml can change externally (e.g. vim) without a file watcher
+      // notification. Always read it fresh — it's small and rarely accessed.
+      (uri) => uri.endsWith('/app/config.yml'),
+    );
     this.readDirectory = cachedByUri(fs.readDirectory.bind(fs));
     this.stat = cachedByUri(fs.stat.bind(fs));
   }
@@ -17,10 +22,14 @@ interface Cached<Fn extends (uri: string) => Promise<any>, T = ReturnType<Fn>> {
   invalidate(uri: string): void;
 }
 
-function cachedByUri<T>(fn: (uri: string) => Promise<T>): Cached<typeof fn> {
+function cachedByUri<T>(
+  fn: (uri: string) => Promise<T>,
+  skipCache?: (uri: string) => boolean,
+): Cached<typeof fn> {
   const cache = new Map<string, Promise<T>>();
 
   function cached(uri: string) {
+    if (skipCache?.(uri)) return fn(uri);
     if (!cache.has(uri)) {
       // I'm intentionally leaving this comment here for debugging purposes :)
       // console.error('cache miss', fn.name, uri);