@platformos/platformos-language-server-common 0.0.7 → 0.0.9

package/src/completions/providers/LiquidDocParamTypeCompletionProvider.ts

@@ -6,11 +6,11 @@ import { filePathSupportsLiquidDoc } from '@platformos/platformos-check-common';
 import {
   getValidParamTypes,
   SupportedDocTagTypes,
-  ThemeDocset,
+  PlatformOSDocset,
 } from '@platformos/platformos-check-common';
 
 export class LiquidDocParamTypeCompletionProvider implements Provider {
-  constructor(private readonly themeDocset: ThemeDocset) {}
+  constructor(private readonly platformosDocset: PlatformOSDocset) {}
 
   async completions(params: LiquidCompletionParams): Promise<CompletionItem[]> {
     if (!params.completionContext) return [];
@@ -44,7 +44,7 @@ export class LiquidDocParamTypeCompletionProvider implements Provider {
       return [];
     }
 
-    const liquidDrops = await this.themeDocset.liquidDrops();
+    const liquidDrops = await this.platformosDocset.liquidDrops();
 
     return Array.from(getValidParamTypes(liquidDrops)).map(([label, description]) => {
       const documentation = description

package/src/completions/providers/LiquidDocTagCompletionProvider.spec.ts

@@ -1,7 +1,6 @@
 import { describe, beforeEach, it, expect } from 'vitest';
 import { CompletionsProvider } from '../CompletionsProvider';
 import { DocumentManager } from '../../documents';
-import { MetafieldDefinitionMap } from '@platformos/platformos-check-common';
 
 describe('Module: LiquidDocTagCompletionProvider', async () => {
   let provider: CompletionsProvider;
@@ -9,15 +8,13 @@ describe('Module: LiquidDocTagCompletionProvider', async () => {
   beforeEach(async () => {
     provider = new CompletionsProvider({
       documentManager: new DocumentManager(),
-      themeDocset: {
+      platformosDocset: {
         graphQL: async () => null,
         filters: async () => [],
         objects: async () => [],
         liquidDrops: async () => [],
         tags: async () => [],
-        systemTranslations: async () => ({}),
       },
-      getMetafieldDefinitions: async (_rootUri: string) => ({}) as MetafieldDefinitionMap,
     });
   });
 
@@ -32,13 +29,6 @@ describe('Module: LiquidDocTagCompletionProvider', async () => {
     );
   });
 
-  it('offers completions within liquid doc tag for blocks', async () => {
-    await expect(provider).to.complete(
-      { source: `{% doc %} @█`, relativePath: 'file://blocks/file.liquid' },
-      ['param', 'example', 'description'],
-    );
-  });
-
   it("does not offer completion if it doesn't start with @", async () => {
     await expect(provider).to.complete(
       { source: `{% doc %} █`, relativePath: 'file://app/views/partials/file.liquid' },
@@ -53,21 +43,6 @@ describe('Module: LiquidDocTagCompletionProvider', async () => {
     );
   });
 
-  it('does not offer completion if it is not a snippet file or block', async () => {
-    await expect(provider).to.complete(
-      { source: `{% doc %} @█`, relativePath: 'file://sections/file.liquid' },
-      [],
-    );
-    await expect(provider).to.complete(
-      { source: `{% doc %} @█`, relativePath: 'file://templates/file.liquid' },
-      [],
-    );
-    await expect(provider).to.complete(
-      { source: `{% doc %} @█`, relativePath: 'file://layout/file.liquid' },
-      [],
-    );
-  });
-
   describe('nodes that accept free-form text', () => {
     it('offers completions when @ is at the start of a new line following an implicit description', async () => {
       await expect(provider).to.complete(

package/src/completions/providers/LiquidTagsCompletionProvider.spec.ts

@@ -1,7 +1,7 @@
 import { describe, beforeEach, it, expect } from 'vitest';
 import { DocumentManager } from '../../documents';
 import { CompletionsProvider } from '../CompletionsProvider';
-import { MetafieldDefinitionMap, TagEntry } from '@platformos/platformos-check-common';
+import { TagEntry } from '@platformos/platformos-check-common';
 import { InsertTextFormat, InsertTextMode, TextEdit } from 'vscode-languageserver-protocol';
 
 const caseSyntax = `{% case variable %}
@@ -38,8 +38,8 @@ endcase`;
 export const tags: TagEntry[] = [
   {
     name: 'render',
-    syntax: "{% render 'snippet' %}",
-    syntax_keywords: [{ keyword: 'snippet', description: '...' }],
+    syntax: "{% render 'partial' %}",
+    syntax_keywords: [{ keyword: 'partial', description: '...' }],
   },
   {
     name: 'for',
@@ -83,15 +83,13 @@ describe('Module: LiquidTagsCompletionProvider', async () => {
   beforeEach(async () => {
     provider = new CompletionsProvider({
       documentManager: new DocumentManager(),
-      themeDocset: {
+      platformosDocset: {
         graphQL: async () => null,
         filters: async () => [],
         objects: async () => [],
         liquidDrops: async () => [],
         tags: async () => tags,
-        systemTranslations: async () => ({}),
       },
-      getMetafieldDefinitions: async (_rootUri: string) => ({}) as MetafieldDefinitionMap,
     });
   });
 
@@ -109,9 +107,6 @@ describe('Module: LiquidTagsCompletionProvider', async () => {
     await expect(provider).to.complete('{% comment %} hello there {% end', ['endcomment']);
     await expect(provider).to.complete('{% if cond %} hello {% else %} then {% end', ['endif']);
     await expect(provider).to.complete('{% for i in (1..3) %}{% end', ['endfor']);
-    await expect(provider).to.complete('{% javascript %} console.log("hi") {% end', [
-      'endjavascript',
-    ]);
     await expect(provider).to.complete('{% form "cart", cart %} ... {% end', ['endform']);
   });
 
@@ -138,10 +133,6 @@ describe('Module: LiquidTagsCompletionProvider', async () => {
       'endif',
     ]);
     await expect(provider).to.complete('{% for i in (1..3) %}{% e', ['echo', 'endfor']);
-    await expect(provider).to.complete('{% javascript %} console.log("hi") {% e', [
-      'echo',
-      'endjavascript',
-    ]);
     await expect(provider).to.complete('{% form "cart", cart %} ... {% e', ['echo', 'endform']);
   });
 
@@ -149,7 +140,6 @@ describe('Module: LiquidTagsCompletionProvider', async () => {
     await expect(provider).to.complete('{% comment %} hello there {% endz', []);
     await expect(provider).to.complete('{% if cond %} hello {% else %} then {% endz', []);
     await expect(provider).to.complete('{% for i in (1..3) %}{% endz', []);
-    await expect(provider).to.complete('{% javascript %} console.log("hi") {% endz', []);
     await expect(provider).to.complete('{% form "cart", cart %} ... {% endz', []);
   });
 
@@ -165,10 +155,6 @@ describe('Module: LiquidTagsCompletionProvider', async () => {
       allTags.concat('endif'),
     );
     await expect(provider).to.complete('{% for i in (1..3) %}{% ', allTags.concat('endfor'));
-    await expect(provider).to.complete(
-      '{% javascript %} console.log("hi") {% ',
-      allTags.concat('endjavascript'),
-    );
     await expect(provider).to.complete(
       '{% form "cart", cart %} ... {% ',
       allTags.concat('endform'),

package/src/completions/providers/LiquidTagsCompletionProvider.ts

@@ -7,7 +7,7 @@ import {
   NodeTypes,
   RAW_TAGS,
 } from '@platformos/liquid-html-parser';
-import { TagEntry, ThemeDocset } from '@platformos/platformos-check-common';
+import { TagEntry, PlatformOSDocset } from '@platformos/platformos-check-common';
 import {
   CompletionItem,
   CompletionItemKind,
@@ -23,7 +23,7 @@ import { CURSOR, LiquidCompletionParams } from '../params';
 import { Provider, createCompletionItem, sortByName } from './common';
 
 export class LiquidTagsCompletionProvider implements Provider {
-  constructor(private readonly themeDocset: ThemeDocset) {}
+  constructor(private readonly platformosDocset: PlatformOSDocset) {}
 
   async completions(params: LiquidCompletionParams): Promise<CompletionItem[]> {
     if (!params.completionContext) return [];
@@ -39,7 +39,7 @@ export class LiquidTagsCompletionProvider implements Provider {
 
     const partial = node.name.replace(CURSOR, '');
     const blockParent = findParentNode(partial, ancestors);
-    const tags = await this.themeDocset.tags();
+    const tags = await this.platformosDocset.tags();
     return tags
       .filter(({ name }) => name.startsWith(partial))
       .sort(sortByName)

package/src/completions/providers/ObjectAttributeCompletionProvider.spec.ts

@@ -2,12 +2,10 @@ import { describe, beforeEach, it, expect, vi } from 'vitest';
 import { CompletionItemKind } from 'vscode-languageserver';
 import { DocumentManager } from '../../documents';
 import { CompletionsProvider } from '../CompletionsProvider';
-import { SettingsSchemaJSONFile } from '../../settings';
-import { MetafieldDefinitionMap, ObjectEntry } from '@platformos/platformos-check-common';
+import { ObjectEntry } from '@platformos/platformos-check-common';
 
 describe('Module: ObjectAttributeCompletionProvider', async () => {
   let provider: CompletionsProvider;
-  let settingsProvider: any;
 
   beforeEach(async () => {
     const _objects: ObjectEntry[] = [
@@ -62,10 +60,9 @@ describe('Module: ObjectAttributeCompletionProvider', async () => {
       },
     ];
 
-    settingsProvider = vi.fn().mockResolvedValue([]);
     provider = new CompletionsProvider({
       documentManager: new DocumentManager(),
-      themeDocset: {
+      platformosDocset: {
         graphQL: async () => null,
         filters: async () => [
           { name: 'split', return_type: [{ type: 'array', array_value: 'string' }] },
@@ -75,10 +72,7 @@ describe('Module: ObjectAttributeCompletionProvider', async () => {
         objects: async () => _objects,
         liquidDrops: async () => _objects,
         tags: async () => [],
-        systemTranslations: async () => ({}),
       },
-      getThemeSettingsSchemaForURI: settingsProvider,
-      getMetafieldDefinitions: async (_rootUri: string) => ({}) as MetafieldDefinitionMap,
     });
   });
 
@@ -498,27 +492,4 @@ describe('Module: ObjectAttributeCompletionProvider', async () => {
       await expect(provider).to.complete(source, ['deep']);
     });
   });
-
-  describe('Case: global settings', () => {
-    it('should complete basic settings by id as expected', async () => {
-      const settings: SettingsSchemaJSONFile = [
-        {
-          name: 'Category',
-          settings: [
-            {
-              type: 'product',
-              id: 'my_product_setting',
-              label: 'Product',
-            },
-          ],
-        },
-      ];
-      settingsProvider.mockResolvedValue(settings);
-
-      const source = `
-        {{ settings.█ }}
-      `;
-      await expect(provider).to.complete(source, ['my_product_setting']);
-    });
-  });
 });

package/src/completions/providers/ObjectCompletionProvider.spec.ts

@@ -1,33 +1,24 @@
 import { describe, beforeEach, it, expect } from 'vitest';
 import { DocumentManager } from '../../documents';
 import { CompletionsProvider } from '../CompletionsProvider';
-import { MetafieldDefinitionMap, ObjectEntry } from '@platformos/platformos-check-common';
+import { ObjectEntry } from '@platformos/platformos-check-common';
 
 describe('Module: ObjectCompletionProvider', async () => {
   let provider: CompletionsProvider;
 
   beforeEach(async () => {
     const _objects: ObjectEntry[] = [
-      { name: 'all_products' },
-      { name: 'global' },
-      {
-        name: 'section',
-        access: {
-          global: false,
-          template: [],
-          parents: [],
-        },
-      },
       {
-        name: 'block',
-        access: {
-          global: false,
-          template: [],
-          parents: [],
-        },
+        name: 'context',
+        access: { global: true, parents: [], template: [] },
+        properties: [
+          { name: 'current_user', return_type: [{ type: 'current_user', name: '' }] },
+          { name: 'params', return_type: [{ type: 'untyped', name: '' }] },
+        ],
       },
+      { name: 'global' },
       {
-        name: 'predictive_search',
+        name: 'form',
         access: {
           global: false,
           template: [],
@@ -35,7 +26,7 @@ describe('Module: ObjectCompletionProvider', async () => {
         },
       },
       {
-        name: 'recommendations',
+        name: 'app',
         access: {
           global: false,
           template: [],
@@ -43,107 +34,43 @@ describe('Module: ObjectCompletionProvider', async () => {
         },
       },
       {
-        name: 'product',
-        properties: [
-          {
-            name: 'metafields',
-          },
-        ],
-      },
-      {
-        name: 'metafield',
-        access: {
-          global: false,
-          template: [],
-          parents: [],
-        },
-        properties: [
-          {
-            name: 'type',
-            description: 'the type of the metafield',
-            return_type: [{ type: 'string', name: '' }],
-          },
-          {
-            name: 'value',
-            description: 'the value of the metafield',
-            return_type: [{ type: 'untyped', name: '' }],
-          },
-        ],
+        name: 'current_user',
+        access: { global: false, parents: [], template: [] },
+        properties: [{ name: 'name' }, { name: 'email' }],
       },
     ];
 
     provider = new CompletionsProvider({
       documentManager: new DocumentManager(),
-      themeDocset: {
+      platformosDocset: {
         graphQL: async () => null,
         filters: async () => [],
         objects: async () => _objects,
         liquidDrops: async () => _objects,
         tags: async () => [],
-        systemTranslations: async () => ({}),
-      },
-      getMetafieldDefinitions: async (_rootUri: string) => {
-        return {
-          article: [],
-          blog: [],
-          collection: [],
-          company: [],
-          company_location: [],
-          location: [],
-          market: [],
-          order: [],
-          page: [],
-          product: [
-            {
-              key: 'color',
-              name: 'color',
-              namespace: 'custom',
-              description: 'the color of the product',
-              type: {
-                category: 'COLOR',
-                name: 'color',
-              },
-            },
-          ],
-          variant: [],
-          shop: [],
-        } as MetafieldDefinitionMap;
       },
     });
   });
 
   it('should complete variable lookups', async () => {
     const contexts = [
-      `{{ a█`,
-      `{% echo a█ %}`,
-      `{% assign x = a█ %}`,
-      `{% for a in a█ %}`,
-      `{% for a in b reversed limit: a█ %}`,
-      `{% paginate b by a█ %}`,
-      `{% paginate b by col, window_size: a█ %}`,
-      `{% if a█ %}`,
-      `{% if a > a█ %}`,
-      `{% if a > b or a█ %}`,
-      `{% if a > b or c > a█ %}`,
-      `{% elsif a > a█ %}`,
-      `{% when a█ %}`,
-      `{% when a, a█ %}`,
-      `{% cycle a█ %}`,
-      `{% cycle 'foo', a█ %}`,
-      `{% cycle 'foo': a█ %}`,
-      `{% render 'snip', var: a█ %}`,
-      `{% render 'snip' for a█ as item %}`,
-      `{% render 'snip' with a█ as name %}`,
-      `{% for x in (1..a█) %}`,
-      // `{% paginate a█ by 50 %}`,
-      `<a-{{ a█ }}`,
-      `<a data-{{ a█ }}`,
-      `<a data={{ a█ }}`,
-      `<a data="{{ a█ }}"`,
-      `<a data='x{{ a█ }}'`,
+      `{{ c█`,
+      `{% echo c█ %}`,
+      `{% assign x = c█ %}`,
+      `{% for a in c█ %}`,
+      `{% for a in b reversed limit: c█ %}`,
+      `{% if c█ %}`,
+      `{% if a > c█ %}`,
+      `{% if a > b or c█ %}`,
+      `{% for x in (1..c█) %}`,
+      `<a-{{ c█ }}`,
+      `<a data-{{ c█ }}`,
+      `<a data={{ c█ }}`,
+      `<a data="{{ c█ }}"`,
+      `<a data='x{{ c█ }}'`,
     ];
     await Promise.all(
-      contexts.map((context) => expect(provider, context).to.complete(context, ['all_products'])),
+      contexts.map((context) => expect(provider, context).to.complete(context, ['context'])),
     );
   });
 
@@ -154,8 +81,6 @@ describe('Module: ObjectCompletionProvider', async () => {
       `{% assign x = █ %}`,
       `{% for a in █ %}`,
       `{% for a in b reversed limit: █ %}`,
-      `{% paginate b by █ %}`,
-      `{% paginate b by col, window_size: █ %}`,
       `{% if █ %}`,
       `{% if a > █ %}`,
       `{% if a > b or █ %}`,
@@ -170,7 +95,6 @@ describe('Module: ObjectCompletionProvider', async () => {
       `{% render 'snip' for █ as item %}`,
       `{% render 'snip' with █ as name %}`,
       `{% for x in (1..█) %}`,
-      // `{% paginate █ by 50 %}`,
       `<a-{{ █ }}`,
       `<a data-{{ █ }}`,
       `<a data={{ █ }}`,
@@ -180,17 +104,15 @@ describe('Module: ObjectCompletionProvider', async () => {
 
     await Promise.all(
       contexts.map((context) =>
-        expect(provider, context).to.complete(context, ['all_products', 'global', 'product']),
+        expect(provider, context).to.complete(context, ['context', 'global']),
       ),
     );
   });
 
   it('should complete contextual variables', async () => {
     const contexts: [string, string][] = [
-      ['{% paginate all_products by 5 %}{{ pagi█ }}{% endpaginate %}', 'paginate'],
-      ['{% form "cart" %}{{ for█ }}{% endform %}', 'form'],
-      ['{% for p in all_products %}{{ for█ }}{% endfor %}', 'forloop'],
-      ['{% tablerow p in all_products %}{{ tablerow█ }}{% endtablerow %}', 'tablerowloop'],
+      ['{% for p in context.posts %}{{ for█ }}{% endfor %}', 'forloop'],
+      ['{% tablerow p in context.posts %}{{ tablerow█ }}{% endtablerow %}', 'tablerowloop'],
       ['{% layout non█ %}', 'none'],
       ['{% increment var %}{{ var█ }}', 'var'],
       ['{% decrement var %}{{ var█ }}', 'var'],
@@ -205,10 +127,8 @@ describe('Module: ObjectCompletionProvider', async () => {
 
   it('should complete relative-path-dependent contextual variables', async () => {
     const contexts: [string, string][] = [
-      ['section', 'sections/main-product.liquid'],
-      ['block', 'blocks/my-block.liquid'],
-      ['predictive_search', 'sections/predictive-search.liquid'],
-      ['recommendations', 'sections/recommendations.liquid'],
+      ['app', 'app/views/partials/my-partial.liquid'],
+      ['app', 'app/lib/helpers/my-helper.liquid'],
     ];
     for (const [object, relativePath] of contexts) {
       const source = `{{ ${object}█ }}`;
@@ -220,13 +140,4 @@ describe('Module: ObjectCompletionProvider', async () => {
   it('should not complete anything if there is nothing to complete', async () => {
     await expect(provider).to.complete('{% assign x = "█" %}', []);
   });
-
-  it('should complete metafields defined by getMetafieldDefinitions', async () => {
-    await expect(provider).to.complete('{% echo product.metafields.█ %}', ['custom']);
-    await expect(provider).to.complete('{% echo product.metafields.custom.█ %}', ['color']);
-    await expect(provider).to.complete('{% echo product.metafields.custom.color.█ %}', [
-      'type',
-      'value',
-    ]);
-  });
 });

package/src/completions/providers/PartialCompletionProvider.spec.ts

@@ -1,29 +1,26 @@
 import { describe, beforeEach, it, expect } from 'vitest';
 import { DocumentManager } from '../../documents';
 import { CompletionsProvider } from '../CompletionsProvider';
-import { MetafieldDefinitionMap } from '@platformos/platformos-check-common';
 
-describe('Module: RenderSnippetCompletionProvider', async () => {
+describe('Module: RenderPartialCompletionProvider', async () => {
   let provider: CompletionsProvider;
 
   beforeEach(async () => {
     provider = new CompletionsProvider({
       documentManager: new DocumentManager(),
-      themeDocset: {
+      platformosDocset: {
         graphQL: async () => null,
         filters: async () => [],
         objects: async () => [],
         liquidDrops: async () => [],
         tags: async () => [],
-        systemTranslations: async () => ({}),
       },
       getTranslationsForURI: async (_) => ({}),
       getPartialNamesForURI: async (_) => ['product-card', 'image'],
-      getMetafieldDefinitions: async (_rootUri: string) => ({}) as MetafieldDefinitionMap,
     });
   });
 
-  it('should complete snippets correctly', async () => {
+  it('should complete partials correctly', async () => {
     await expect(provider).to.complete('{% render "', ['product-card', 'image']);
   });
 });
@@ -32,13 +29,12 @@ describe('Module: PartialCompletionProvider with paths', async () => {
   it('should complete module paths - /modules/user/commands/test', async () => {
     const provider = new CompletionsProvider({
       documentManager: new DocumentManager(),
-      themeDocset: {
+      platformosDocset: {
         graphQL: async () => null,
         filters: async () => [],
         objects: async () => [],
         liquidDrops: async () => [],
         tags: async () => [],
-        systemTranslations: async () => ({}),
       },
       getTranslationsForURI: async (_) => ({}),
       getPartialNamesForURI: async (_uri, partial, _tag) => {
@@ -47,7 +43,6 @@ describe('Module: PartialCompletionProvider with paths', async () => {
         }
         return [];
       },
-      getMetafieldDefinitions: async (_rootUri: string) => ({}) as MetafieldDefinitionMap,
     });
 
     await expect(provider).to.complete('{% render "/modules/user/commands', ['test']);
@@ -56,13 +51,12 @@ describe('Module: PartialCompletionProvider with paths', async () => {
   it('should complete root commands path - /commands/test2', async () => {
     const provider = new CompletionsProvider({
       documentManager: new DocumentManager(),
-      themeDocset: {
+      platformosDocset: {
         graphQL: async () => null,
         filters: async () => [],
         objects: async () => [],
         liquidDrops: async () => [],
         tags: async () => [],
-        systemTranslations: async () => ({}),
       },
       getTranslationsForURI: async (_) => ({}),
       getPartialNamesForURI: async (_uri, partial, _tag) => {
@@ -71,7 +65,6 @@ describe('Module: PartialCompletionProvider with paths', async () => {
         }
         return [];
       },
-      getMetafieldDefinitions: async (_rootUri: string) => ({}) as MetafieldDefinitionMap,
     });
 
     await expect(provider).to.complete('{% render "/commands', ['test2']);
@@ -80,13 +73,12 @@ describe('Module: PartialCompletionProvider with paths', async () => {
   it('should complete multiple files in directory', async () => {
     const provider = new CompletionsProvider({
       documentManager: new DocumentManager(),
-      themeDocset: {
+      platformosDocset: {
         graphQL: async () => null,
         filters: async () => [],
         objects: async () => [],
         liquidDrops: async () => [],
         tags: async () => [],
-        systemTranslations: async () => ({}),
       },
       getTranslationsForURI: async (_) => ({}),
       getPartialNamesForURI: async (_uri, partial, _tag) => {
@@ -95,7 +87,6 @@ describe('Module: PartialCompletionProvider with paths', async () => {
         }
         return [];
       },
-      getMetafieldDefinitions: async (_rootUri: string) => ({}) as MetafieldDefinitionMap,
     });
 
     await expect(provider).to.complete('{% render "/modules/user/commands', [

package/src/completions/providers/RenderPartialParameterCompletionProvider.spec.ts

@@ -1,14 +1,14 @@
 import { describe, beforeEach, it, expect } from 'vitest';
 import { CompletionsProvider } from '../CompletionsProvider';
 import { DocumentManager } from '../../documents';
-import { MetafieldDefinitionMap, DocDefinition } from '@platformos/platformos-check-common';
+import { DocDefinition } from '@platformos/platformos-check-common';
 
-const uri = 'file:///snippets/product-card.liquid';
+const uri = 'file:///app/views/partials/product-card.liquid';
 
-describe('Module: RenderSnippetParameterCompletionProvider', async () => {
+describe('Module: RenderPartialParameterCompletionProvider', async () => {
   let provider: CompletionsProvider;
-  const mockSnippetName = 'product-card';
-  const mockSnippetDefinition: DocDefinition = {
+  const mockPartialName = 'product-card';
+  const mockPartialDefinition: DocDefinition = {
     uri,
     liquidDoc: {
       parameters: [
@@ -54,25 +54,23 @@ describe('Module: RenderSnippetParameterCompletionProvider', async () => {
   beforeEach(async () => {
     provider = new CompletionsProvider({
       documentManager: new DocumentManager(),
-      themeDocset: {
+      platformosDocset: {
         graphQL: async () => null,
         filters: async () => [],
         objects: async () => [],
         liquidDrops: async () => [],
         tags: async () => [],
-        systemTranslations: async () => ({}),
       },
-      getMetafieldDefinitions: async (_rootUri: string) => ({}) as MetafieldDefinitionMap,
-      getDocDefinitionForURI: async (_uri, _type, snippetName) => {
-        if (mockSnippetName === snippetName) {
-          return mockSnippetDefinition;
+      getDocDefinitionForURI: async (_uri, partialName) => {
+        if (mockPartialName === partialName) {
+          return mockPartialDefinition;
         }
       },
     });
   });
 
   it("provide completion options that doesn't already exist in render tag", async () => {
-    await expect(provider).to.complete(`{% render '${mockSnippetName}', █ %}`, [
+    await expect(provider).to.complete(`{% render '${mockPartialName}', █ %}`, [
       'title',
       'border-radius',
       'no-type',
@@ -80,12 +78,12 @@ describe('Module: RenderSnippetParameterCompletionProvider', async () => {
       'no-type-or-description',
     ]);
     await expect(provider).to.complete(
-      `{% render '${mockSnippetName}', title: 'foo', border-radius: 5, █ %}`,
+      `{% render '${mockPartialName}', title: 'foo', border-radius: 5, █ %}`,
       ['no-type', 'no-description', 'no-type-or-description'],
     );
   });
 
-  it('does not provide completion options if the snippet does not exist', async () => {
-    await expect(provider).to.complete(`{% render 'fake-snippet', █ %}`, []);
+  it('does not provide completion options if the partial does not exist', async () => {
+    await expect(provider).to.complete(`{% render 'fake-partial', █ %}`, []);
   });
 });