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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformos/platformos-language-server-common",
-  "version": "0.0.13",
+  "version": "0.0.16",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "platformOS",
@@ -27,9 +27,9 @@
     "type-check": "tsc --noEmit -p ./tsconfig.json"
   },
   "dependencies": {
-    "@platformos/liquid-html-parser": "^0.0.12",
-    "@platformos/platformos-check-common": "0.0.13",
-    "@platformos/platformos-graph": "0.0.13",
+    "@platformos/liquid-html-parser": "^0.0.15",
+    "@platformos/platformos-check-common": "0.0.16",
+    "@platformos/platformos-graph": "0.0.16",
     "@vscode/web-custom-data": "^0.4.6",
     "graphql": "^16.12.0",
     "graphql-language-service": "^5.2.2",

package/src/definitions/providers/PageRouteDefinitionProvider.spec.ts

@@ -547,6 +547,29 @@ describe('Module: PageRouteDefinitionProvider', () => {
       expect(result).toHaveLength(1);
       expect(result[0].targetUri).toBe('file:///project/app/views/pages/about.html.liquid');
     });
+
+    it('navigates when assign is inside a {% liquid %} block in the same container', async () => {
+      setup({
+        'app/views/pages/about.html.liquid': '<h1>About</h1>',
+      });
+
+      const source =
+        '{% if true %}{% liquid\n  assign url = "/about"\n%}<a href="{{ url }}">About</a>{% endif %}';
+      documentManager.open('file:///project/app/views/pages/home.html.liquid', source, 1);
+
+      const urlOffset = source.indexOf('{{ url }}');
+      const urlLine = source.slice(0, urlOffset).split('\n').length - 1;
+      const urlChar = urlOffset - source.lastIndexOf('\n', urlOffset - 1) - 1;
+      const params: DefinitionParams = {
+        textDocument: { uri: 'file:///project/app/views/pages/home.html.liquid' },
+        position: { line: urlLine, character: urlChar + 3 }, // Inside {{ url }}
+      };
+
+      const result = await provider.definitions(params);
+      assert(result);
+      expect(result).toHaveLength(1);
+      expect(result[0].targetUri).toBe('file:///project/app/views/pages/about.html.liquid');
+    });
   });
 
   describe('format-aware go-to-definition', () => {

package/src/definitions/providers/RenderPartialDefinitionProvider.spec.ts

@@ -48,13 +48,17 @@ describe('RenderPartialDefinitionProvider', () => {
       expect(result[0].targetUri).toBe('file:///project/app/views/partials/card.liquid');
     });
 
-    it('should NOT use search paths for regular render tags', async () => {
+    it('should NOT use search paths for regular render tags — falls back to default creation path', async () => {
+      // The file only exists under a search path (theme/dress/card.liquid), not the standard path.
+      // render should NOT pick up search-path files; instead it falls back to the default
+      // app/views/partials/card.liquid creation path.
       const result = await getDefinitions("{% render 'card' %}", 12, {
         'project/app/config.yml': 'theme_search_paths:\n  - theme/dress',
         'project/app/views/partials/theme/dress/card.liquid': 'dress card',
       });
 
-      expect(result).toHaveLength(0);
+      expect(result).toHaveLength(1);
+      expect(result[0].targetUri).toBe('file:///project/app/views/partials/card.liquid');
     });
   });
 
@@ -130,6 +134,37 @@ describe('RenderPartialDefinitionProvider', () => {
     });
   });
 
+  describe('missing files — fall back to default path', () => {
+    it('render: missing partial resolves to app/views/partials', async () => {
+      const result = await getDefinitions("{% render 'my/missing/partial' %}", 12, {});
+
+      expect(result).toHaveLength(1);
+      expect(result[0].targetUri).toBe(
+        'file:///project/app/views/partials/my/missing/partial.liquid',
+      );
+    });
+
+    it('function: missing partial resolves to app/lib', async () => {
+      const result = await getDefinitions("{% function result = 'commands/missing' %}", 24, {});
+
+      expect(result).toHaveLength(1);
+      expect(result[0].targetUri).toBe('file:///project/app/lib/commands/missing.liquid');
+    });
+
+    it('graphql: missing file resolves to app/graphql', async () => {
+      const result = await getDefinitions("{% graphql g = 'users/missing' %}", 18, {});
+
+      expect(result).toHaveLength(1);
+      expect(result[0].targetUri).toBe('file:///project/app/graphql/users/missing.graphql');
+    });
+
+    it('theme_render_rc: missing file returns empty (no default path)', async () => {
+      const result = await getDefinitions("{% theme_render_rc 'missing' %}", 20, {});
+
+      expect(result).toHaveLength(0);
+    });
+  });
+
   describe('non-matching nodes', () => {
     it('should return empty for non-string nodes', async () => {
       const result = await getDefinitions("{% assign x = 'hello' %}", 3, {});

package/src/definitions/providers/RenderPartialDefinitionProvider.ts

@@ -47,7 +47,7 @@ export class RenderPartialDefinitionProvider implements BaseDefinitionProvider {
     const root = URI.parse(rootUri);
     const searchPaths = await this.searchPathsCache.get(root);
     const docType = (tag as LiquidTag).name as DocumentType;
-    const fileUri = await this.documentsLocator.locate(
+    const fileUri = await this.documentsLocator.locateOrDefault(
       root,
       docType,
       (node as LiquidString).value,

package/src/documentLinks/DocumentLinksProvider.ts

@@ -64,18 +64,19 @@ function documentLinksVisitor(
 
       // render, include, function, theme_render_rc all have a .partial field
       if ('partial' in markup && isLiquidString(markup.partial)) {
-        return DocumentLink.create(
-          range(textDocument, markup.partial),
-          await documentsLocator.locate(root, name, markup.partial.value, searchPaths),
+        const uri = await documentsLocator.locateOrDefault(
+          root,
+          name,
+          markup.partial.value,
+          searchPaths,
         );
+        return DocumentLink.create(range(textDocument, markup.partial), uri);
       }
 
       // graphql has a .graphql field
       if ('graphql' in markup && isLiquidString(markup.graphql)) {
-        return DocumentLink.create(
-          range(textDocument, markup.graphql),
-          await documentsLocator.locate(root, name, markup.graphql.value),
-        );
+        const uri = await documentsLocator.locateOrDefault(root, name, markup.graphql.value);
+        return DocumentLink.create(range(textDocument, markup.graphql), uri);
       }
     },
     async LiquidVariable(node) {

package/src/server/startServer.spec.ts

@@ -7,11 +7,13 @@ import {
   DidRenameFilesNotification,
   FileChangeType,
   PublishDiagnosticsNotification,
+  DefinitionRequest,
 } from 'vscode-languageserver';
 import { MockConnection, mockConnection } from '../test/MockConnection';
 import { Dependencies } from '../types';
 import { CHECK_ON_CHANGE, CHECK_ON_OPEN, CHECK_ON_SAVE } from './Configuration';
 import { startServer } from './startServer';
+import { SearchPathsLoader } from '../utils/searchPaths';
 
 const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
@@ -76,6 +78,7 @@ describe('Module: server', () => {
 
   afterEach(() => {
     vi.useRealTimers();
+    vi.restoreAllMocks();
   });
 
   it("should log Let's roll! on successful setup", async () => {
@@ -315,6 +318,65 @@ describe('Module: server', () => {
     );
   });
 
+  it('go-to-definition reflects updated search paths after saving app/config.yml', async () => {
+    // Setup file tree: config pointing to theme/dress, both dress and simple partials present
+    fileTree['app/config.yml'] = 'theme_search_paths:\n  - theme/dress';
+    fileTree['app/views/partials/theme/dress/card.liquid'] = 'dress card';
+    fileTree['app/views/partials/theme/simple/card.liquid'] = 'simple card';
+
+    connection.setup();
+    await flushAsync();
+
+    // Open a document referencing the partial
+    const source = "{% theme_render_rc 'card' %}";
+    connection.openDocument(filePath, source);
+    await flushAsync();
+
+    // Request definition — character 21 is inside 'card'
+    const params = {
+      textDocument: { uri: fileURI },
+      position: { line: 0, character: 21 },
+    };
+    const result1 = (await connection.triggerRequest(DefinitionRequest.method, params)) as any[];
+    expect(result1).toHaveLength(1);
+    expect(result1[0].targetUri).toContain('theme/dress/card.liquid');
+
+    // Mutate config to point to theme/simple, then save the config file
+    fileTree['app/config.yml'] = 'theme_search_paths:\n  - theme/simple';
+    connection.saveDocument('app/config.yml');
+    await flushAsync();
+
+    // Definition should now resolve to theme/simple
+    const result2 = (await connection.triggerRequest(DefinitionRequest.method, params)) as any[];
+    expect(result2).toHaveLength(1);
+    expect(result2[0].targetUri).toContain('theme/simple/card.liquid');
+  });
+
+  it('should invalidate search-paths cache immediately when app/config.yml is saved', async () => {
+    connection.setup();
+    await flushAsync();
+
+    const invalidateSpy = vi.spyOn(SearchPathsLoader.prototype, 'invalidate');
+
+    // Saving app/config.yml should immediately invalidate the cache
+    connection.saveDocument('app/config.yml');
+    await flushAsync();
+
+    expect(invalidateSpy).toHaveBeenCalledOnce();
+  });
+
+  it('should NOT invalidate search-paths cache when an unrelated file is saved', async () => {
+    connection.setup();
+    await flushAsync();
+
+    const invalidateSpy = vi.spyOn(SearchPathsLoader.prototype, 'invalidate');
+
+    connection.saveDocument('app/views/partials/code.liquid');
+    await flushAsync();
+
+    expect(invalidateSpy).not.toHaveBeenCalled();
+  });
+
   it('should trigger a re-check on did delete files notifications', async () => {
     connection.setup();
     await flushAsync();

package/src/test/MockConnection.ts

@@ -2,6 +2,7 @@ import { vi } from 'vitest';
 import { EventEmitter } from 'node:events';
 import { createConnection } from 'vscode-languageserver/lib/common/server';
 import {
+  CancellationToken,
   ClientCapabilities,
   DidChangeTextDocumentNotification,
   DidCloseTextDocumentNotification,
@@ -47,7 +48,11 @@ type MockConnectionMethods = {
  */
 export type MockConnection = ReturnType<typeof createConnection> & MockConnectionMethods;
 
-function protocolConnection(requests: EventEmitter, notifications: EventEmitter) {
+function protocolConnection(
+  requests: EventEmitter,
+  notifications: EventEmitter,
+  requestHandlers: Map<string, Function>,
+) {
   return {
     dispose: vi.fn(),
     end: vi.fn(),
@@ -61,12 +66,13 @@ function protocolConnection(requests: EventEmitter, notifications: EventEmitter)
       notifications.addListener(type.method, handler);
     }),
     onRequest: vi.fn().mockImplementation((type: MessageSignature, handler) => {
+      requestHandlers.set(type.method, handler);
       requests.addListener(type.method, handler);
     }),
     onUnhandledNotification: vi.fn(),
     sendNotification: vi.fn().mockReturnValue(Promise.resolve()),
     sendProgress: vi.fn(),
-    sendRequest: vi.fn(),
+    sendRequest: vi.fn().mockReturnValue(Promise.resolve()),
     trace: vi.fn().mockReturnValue(Promise.resolve()),
   } satisfies ProtocolConnection;
 }
@@ -80,7 +86,8 @@ export function mockConnection(rootUri: string): MockConnection {
 
   const requests = new EventEmitter();
   const notifications = new EventEmitter();
-  const spies = protocolConnection(requests, notifications);
+  const requestHandlers = new Map<string, Function>();
+  const spies = protocolConnection(requests, notifications, requestHandlers);
 
   // Create a real "connection" with the fake communication channel
   const connection = createConnection(() => spies, watchDog);
@@ -92,10 +99,15 @@ export function mockConnection(rootUri: string): MockConnection {
     notifications.emit(method, params);
   };
 
-  // Create a mock way to trigger requests in our tests
+  // Create a mock way to trigger requests in our tests and get the response back.
+  // Calls the registered handler directly so that the return value is available.
   const triggerRequest: MockConnection['triggerRequest'] = async (...args: any[]) => {
     const [type, params] = args;
     const method = typeof type === 'string' ? type : type.method;
+    const handler = requestHandlers.get(method);
+    if (handler) {
+      return handler(params, CancellationToken.None);
+    }
     requests.emit(method, params);
   };