@platformos/platformos-language-server-common 0.0.2

package/src/json/completions/providers/ReferencedBlockTypeCompletionProvider.ts

@@ -0,0 +1,120 @@
+import { deepGet, isError } from '@platformos/platformos-check-common';
+import { JSONPath } from 'vscode-json-languageservice';
+import { JSONCompletionItem } from 'vscode-json-languageservice/lib/umd/jsonContributions';
+import { isLiquidRequestContext, RequestContext } from '../../RequestContext';
+import { isSectionOrBlockFile } from '../../utils';
+import { JSONCompletionProvider } from '../JSONCompletionProvider';
+import {
+  createBlockNameCompletionItems,
+  isSectionOrBlockSchema,
+} from './BlockTypeCompletionProvider';
+import { GetThemeBlockNames, GetThemeBlockSchema } from '../../JSONContributions';
+
+/**
+ * The ReferencedBlockTypeCompletionProvider offers value completions of the
+ * `presets.[](recursive .blocks.[]).type` value and `default.blocks.[].type` value inside
+ * section and theme block `{% schema %}` tags.
+ *
+ * @example
+ * {% schema %}
+ * {
+ *   "presets": [
+ *     {
+ *       "blocks": [
+ *         { "type": "█" },
+ *       ]
+ *     },
+ *   ],
+ *   "default": {
+ *     "blocks": [
+ *       { "type": "█" },
+ *     ]
+ *   }
+ * }
+ * {% endschema %}
+ */
+export class ReferencedBlockTypeCompletionProvider implements JSONCompletionProvider {
+  constructor(
+    private getThemeBlockNames: GetThemeBlockNames,
+    private getThemeBlockSchema: GetThemeBlockSchema,
+  ) {}
+
+  async completeValue(context: RequestContext, path: JSONPath): Promise<JSONCompletionItem[]> {
+    if (
+      !isSectionOrBlockFile(context.doc.uri) ||
+      !isLiquidRequestContext(context) ||
+      !isBlockTypePath(path)
+    ) {
+      return [];
+    }
+
+    const { doc } = context;
+    const schema = await doc.getSchema();
+
+    if (!schema || isError(schema.parsed) || !isSectionOrBlockSchema(schema)) {
+      return [];
+    }
+
+    let parsedBlockSchema = schema.parsed;
+
+    if (isNestedBlockPath(path)) {
+      const parentBlockName = getParentBlockName(schema.parsed, path);
+      if (!parentBlockName) {
+        return [];
+      }
+
+      const parentBlockSchema = await this.getThemeBlockSchema(doc.uri, parentBlockName);
+
+      if (
+        !parentBlockSchema ||
+        isError(parentBlockSchema.parsed) ||
+        !isSectionOrBlockSchema(parentBlockSchema)
+      ) {
+        return [];
+      }
+
+      parsedBlockSchema = parentBlockSchema.parsed;
+    }
+
+    const blocks: { type: string }[] = parsedBlockSchema.blocks || [];
+
+    const blockGroups = {
+      themeBlocks: false,
+      specificBlockNames: [] as string[],
+    };
+
+    blocks.forEach((block) => {
+      if (block.type === '@theme') {
+        blockGroups.themeBlocks = true;
+      } else if (!block.type.startsWith('@')) {
+        blockGroups.specificBlockNames.push(block.type);
+      }
+    });
+
+    let blockNames = blockGroups.specificBlockNames;
+
+    if (blockGroups.themeBlocks) {
+      blockNames.push(...(await this.getThemeBlockNames(doc.uri, false)));
+    }
+
+    return createBlockNameCompletionItems(blockNames);
+  }
+}
+
+// `blocks` can be nested within other `blocks`
+// We need to ensure the last leg of the path is { "blocks": [{ "type": "█" }] }
+function isBlockTypePath(path: JSONPath) {
+  return (
+    (path.at(0) === 'presets' || path.at(0) === 'default') &&
+    path.at(-3) === 'blocks' &&
+    path.at(-1) === 'type'
+  );
+}
+
+function isNestedBlockPath(path: JSONPath) {
+  return path.at(-5) === 'blocks' && path.at(-3) === 'blocks' && path.at(-1) === 'type';
+}
+
+function getParentBlockName(parsedSchema: any, path: JSONPath) {
+  return deepGet(parsedSchema, [...path.slice(0, -3), 'type']);
+}

package/src/json/completions/providers/SchemaTranslationCompletionProvider.ts

@@ -0,0 +1,51 @@
+import { deepGet } from '@platformos/platformos-check-common';
+import { CompletionItemKind, JSONPath } from 'vscode-json-languageservice';
+import {
+  GetTranslationsForURI,
+  renderTranslation,
+  translationOptions,
+} from '../../../translations';
+import { isLiquidRequestContext, RequestContext } from '../../RequestContext';
+import { isSectionOrBlockFile } from '../../utils';
+import { JSONCompletionItem, JSONCompletionProvider } from '../JSONCompletionProvider';
+
+export class SchemaTranslationsCompletionProvider implements JSONCompletionProvider {
+  constructor(private getDefaultSchemaTranslations: GetTranslationsForURI) {}
+
+  async completeValue(context: RequestContext, path: JSONPath): Promise<JSONCompletionItem[]> {
+    if (!isSectionOrBlockFile(context.doc.uri) || !isLiquidRequestContext(context)) {
+      return [];
+    }
+
+    const { doc, parsed } = context;
+
+    const label = deepGet(parsed, path);
+    if (!label || typeof label !== 'string' || !label.startsWith('t:')) {
+      return [];
+    }
+
+    const partial = /^t:(.*)/.exec(label)?.[1];
+    if (partial === undefined) return [];
+
+    const translations = await this.getDefaultSchemaTranslations(doc.uri);
+
+    // We'll let the frontend do the filtering. But we'll only include shopify
+    // translations if the shopify prefix is present
+    const options = translationOptions(translations);
+
+    return options.map((option): JSONCompletionItem => {
+      const tLabel = `t:${option.path.join('.')}`;
+      return {
+        label: tLabel,
+        kind: CompletionItemKind.Value,
+        filterText: `"${tLabel}"`,
+        insertText: `"${tLabel}"`,
+        insertTextFormat: 1,
+        documentation: {
+          kind: 'markdown',
+          value: renderTranslation(option.translation),
+        },
+      };
+    });
+  }
+}

package/src/json/completions/providers/SettingsPropertyCompletionProvider.spec.ts

@@ -0,0 +1,211 @@
+import { describe, it, expect, assert, beforeEach } from 'vitest';
+import { JSONLanguageService } from '../../JSONLanguageService';
+import { DocumentManager } from '../../../documents';
+import {
+  getRequestParams,
+  isCompletionList,
+  mockJSONLanguageService,
+} from '../../test/test-helpers';
+
+describe('Unit: SettingsPropertyCompletionProvider', () => {
+  const rootUri = 'file:///root/';
+  let jsonLanguageService: JSONLanguageService;
+  let documentManager: DocumentManager;
+
+  beforeEach(async () => {
+    documentManager = new DocumentManager(
+      undefined, // don't need a fs
+      undefined, // don't need a connection
+      undefined, // don't need client capabilities
+      async () => 'theme', // 'theme' mode
+      async () => false, // schema is invalid for tests
+    );
+    jsonLanguageService = mockJSONLanguageService(
+      rootUri,
+      documentManager,
+      async (_uri: string) => ({
+        general: {
+          fake: 'Fake Setting',
+        },
+      }),
+    );
+
+    await jsonLanguageService.setup({
+      textDocument: {
+        completion: {
+          contextSupport: true,
+          completionItem: {
+            snippetSupport: true,
+            commitCharactersSupport: true,
+            documentationFormat: ['markdown'],
+            deprecatedSupport: true,
+            preselectSupport: true,
+          },
+        },
+      },
+    });
+  });
+
+  describe('section file with valid schema', () => {
+    const tests = [
+      {
+        label: 'preset',
+        schemaTemplate: (setting: object) => {
+          return {
+            presets: [setting],
+          };
+        },
+      },
+      {
+        label: 'default',
+        schemaTemplate: (setting: object) => {
+          return {
+            default: setting,
+          };
+        },
+      },
+    ];
+
+    for (const test of tests) {
+      describe(`${test.label} settings`, () => {
+        it(`completes ${test.label} setting property when settings exist`, async () => {
+          const schema = {
+            settings: [{ id: 'custom-setting' }, { id: 'fake-setting' }, {}],
+            ...test.schemaTemplate({
+              settings: {
+                '█': '',
+              },
+            }),
+          };
+          const source = `
+            {% schema %}
+              ${JSON.stringify(schema)}
+            {% endschema %}
+          `;
+          const params = getRequestParams(documentManager, 'sections/section.liquid', source);
+          const completions = await jsonLanguageService.completions(params);
+
+          assert(isCompletionList(completions));
+          expect(completions.items).to.have.lengthOf(2);
+          expect(completions.items.map((item) => item.label)).to.include.members([
+            `"custom-setting"`,
+            `"fake-setting"`,
+          ]);
+        });
+
+        it(`offers no suggestions for ${test.label} setting property when there are no settings`, async () => {
+          const schema = {
+            ...test.schemaTemplate({
+              settings: {
+                '█': '',
+              },
+            }),
+          };
+          const source = `
+            {% schema %}
+              ${JSON.stringify(schema)}
+            {% endschema %}
+          `;
+          const params = getRequestParams(documentManager, 'sections/section.liquid', source);
+          const completions = await jsonLanguageService.completions(params);
+
+          assert(isCompletionList(completions));
+          expect(completions.items).to.have.lengthOf(0);
+          expect(completions.items.map((item) => item.label)).to.include.members([]);
+        });
+
+        it(`offers ${test.label} setting completion with docs from setting.label`, async () => {
+          const schema = {
+            settings: [
+              { id: 'custom-setting', label: 'Custom Setting' },
+              { id: 'fake-setting', label: 't:general.fake' },
+              {},
+            ],
+            ...test.schemaTemplate({
+              settings: {
+                '█': '',
+              },
+            }),
+          };
+          const source = `
+            {% schema %}
+              ${JSON.stringify(schema)}
+            {% endschema %}
+          `;
+          const params = getRequestParams(documentManager, 'sections/section.liquid', source);
+          const completions = await jsonLanguageService.completions(params);
+
+          assert(isCompletionList(completions));
+          expect(completions.items).to.have.lengthOf(2);
+          expect(completions.items).toEqual(
+            expect.arrayContaining([
+              expect.objectContaining({
+                documentation: { kind: 'markdown', value: 'Custom Setting' },
+              }),
+              expect.objectContaining({
+                documentation: { kind: 'markdown', value: 'Fake Setting' },
+              }),
+            ]),
+          );
+        });
+      });
+    }
+
+    describe('block file with valid schema', () => {
+      it(`offers no suggestions for default setting property when file is block`, async () => {
+        const source = `
+          {% schema %}
+          {
+            "settings": [
+              {"id": "custom-setting"},
+              {"id": "fake-setting"},
+              {},
+            ],
+            "default": {
+              "settings": {
+                "█": ""
+              }
+            }
+          }
+          {% endschema %}
+        `;
+        const params = getRequestParams(documentManager, 'blocks/block.liquid', source);
+        const completions = await jsonLanguageService.completions(params);
+
+        assert(isCompletionList(completions));
+        expect(completions.items).to.have.lengthOf(0);
+        expect(completions.items.map((item) => item.label)).to.include.members([]);
+      });
+    });
+  });
+
+  describe('invalid schema', () => {
+    it('completes preset setting property when settings exist and schema has small errors', async () => {
+      const source = `
+        {% schema %}
+        {
+          "settings": [
+            {"id": "custom-setting"},
+            {"id": "fake-setting"},
+            {},
+          ],
+          "presets": [{
+            "settings": {
+              "█"
+            }
+          }]
+        }
+        {% endschema %}
+      `;
+      const params = getRequestParams(documentManager, 'blocks/block.liquid', source);
+      const completions = await jsonLanguageService.completions(params);
+
+      assert(isCompletionList(completions));
+      expect(completions.items).to.have.lengthOf(2);
+      expect(completions.items.map((item) => item.label)).to.include.members([
+        `"custom-setting"`,
+        `"fake-setting"`,
+      ]);
+    });
+  });
+});

package/src/json/completions/providers/SettingsPropertyCompletionProvider.ts

@@ -0,0 +1,75 @@
+import { isError, SourceCodeType } from '@platformos/platformos-check-common';
+import { JSONPath } from 'vscode-json-languageservice';
+import { JSONCompletionItem } from 'vscode-json-languageservice/lib/umd/jsonContributions';
+import { RequestContext } from '../../RequestContext';
+import { isBlockFile, isSectionFile } from '../../utils';
+import { JSONCompletionProvider } from '../JSONCompletionProvider';
+import { GetTranslationsForURI } from '../../../translations';
+import { isSectionOrBlockSchema } from './BlockTypeCompletionProvider';
+import { schemaSettingsPropertyCompletionItems } from '../../schemaSettings';
+
+/**
+ * The SettingsPropertyCompletionProvider offers property completions for:
+ * - `presets.[].settings.[]` objects inside `{% schema %}` tag in sections and blocks
+ * - `default.settings` object inside `{% schema %}` tag in sections
+ *
+ * @example
+ * {% schema %}
+ * {
+ *   "presets": [
+ *     {
+ *       "settings": [
+ *         { "█" },
+ *       ]
+ *     },
+ *   ],
+ *   "default": {
+ *     "settings": {
+ *       "█"
+ *     }
+ *   }
+ * }
+ * {% endschema %}
+ */
+export class SettingsPropertyCompletionProvider implements JSONCompletionProvider {
+  constructor(public getDefaultSchemaTranslations: GetTranslationsForURI) {}
+
+  async completeProperty(context: RequestContext, path: JSONPath): Promise<JSONCompletionItem[]> {
+    const { doc } = context;
+
+    if (doc.type !== SourceCodeType.LiquidHtml) return [];
+
+    // section files can have schemas with `presets` and `default`
+    // block files can have schemas with `presets` only
+    if (
+      !(isSectionFile(doc.uri) && (isPresetSettingsPath(path) || isDefaultSettingsPath(path))) &&
+      !(isBlockFile(doc.uri) && isPresetSettingsPath(path))
+    ) {
+      return [];
+    }
+
+    const schema = await doc.getSchema();
+
+    if (!schema || !isSectionOrBlockSchema(schema) || isError(schema.parsed)) {
+      return [];
+    }
+
+    const parsedSchema = schema.parsed;
+
+    if (!parsedSchema?.settings || !Array.isArray(parsedSchema.settings)) {
+      return [];
+    }
+
+    const translations = await this.getDefaultSchemaTranslations(doc.textDocument.uri);
+
+    return schemaSettingsPropertyCompletionItems(parsedSchema.settings, translations);
+  }
+}
+
+function isPresetSettingsPath(path: JSONPath) {
+  return path.length === 3 && path.at(0) === 'presets' && path.at(2) === 'settings';
+}
+
+function isDefaultSettingsPath(path: JSONPath) {
+  return path.length === 2 && path.at(0) === 'default' && path.at(1) === 'settings';
+}

package/src/json/documentLinks/DocumentLinksProvider.spec.ts

@@ -0,0 +1,223 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { DocumentManager } from '../../documents';
+import { createJSONDocumentLinksVisitor } from './DocumentLinksProvider';
+import { toJSONAST, visit } from '@platformos/platformos-check-common';
+import { URI } from 'vscode-uri';
+import { JSONLanguageService } from '../JSONLanguageService';
+
+describe('JSON Document Links', () => {
+  let documentManager: DocumentManager;
+  let rootUri: string;
+  let uriString: string;
+  let jsonLanguageService: JSONLanguageService;
+
+  beforeEach(async () => {
+    documentManager = new DocumentManager();
+    rootUri = 'file:///path/to/project';
+
+    // Create a minimal JSONLanguageService for testing
+    jsonLanguageService = new JSONLanguageService(
+      documentManager,
+      { schemas: async () => [] },
+      async () => ({}),
+      async () => 'theme',
+      async () => [],
+      async () => undefined,
+      async () => rootUri,
+    );
+
+    // Initialize the service to resolve the initialized promise
+    await jsonLanguageService.setup({});
+  });
+
+  describe('Schema Tags in Liquid Files', () => {
+    it('should return document links for block types in schema tags', async () => {
+      uriString = 'file:///path/to/sections/header.liquid';
+      rootUri = 'file:///path/to/project';
+
+      const schemaContent = `
+        {
+          "name": "Header",
+          "blocks": [
+            { "type": "logo" },
+            { "type": "navigation" }
+          ]
+        }
+      `;
+
+      const liquidContent = `
+        <div>Header content</div>
+        
+        {% schema %}
+        ${schemaContent}
+        {% endschema %}
+      `;
+
+      documentManager.open(uriString, liquidContent, 1);
+
+      const textDocument = documentManager.get(uriString)!.textDocument;
+      const schemaOffset = liquidContent.indexOf(schemaContent);
+
+      const visitor = await createJSONDocumentLinksVisitor(
+        textDocument,
+        URI.parse(rootUri),
+        schemaOffset,
+      );
+      const ast = toJSONAST(schemaContent);
+
+      if (ast instanceof Error) throw ast;
+      const result = await visit(ast, visitor);
+
+      expect(result).toHaveLength(2);
+      expect(result[0].target).toBe('file:///path/to/project/blocks/logo.liquid');
+      expect(result[1].target).toBe('file:///path/to/project/blocks/navigation.liquid');
+    });
+
+    it('should handle section types in schema tags', async () => {
+      uriString = 'file:///path/to/sections/main-collection.liquid';
+      rootUri = 'file:///path/to/project';
+
+      const schemaContent = `
+        {
+          "name": "Collection",
+          "blocks": [
+            {
+              "type": "text",
+              "settings": []
+            }
+          ],
+          "presets": [
+            {
+              "name": "Default",
+              "blocks": [
+                { "type": "text" }
+              ]
+            }
+          ]
+        }
+      `;
+
+      const liquidContent = `
+        <div>Collection content</div>
+        
+        {% schema %}
+        ${schemaContent}
+        {% endschema %}
+      `;
+
+      documentManager.open(uriString, liquidContent, 1);
+
+      const textDocument = documentManager.get(uriString)!.textDocument;
+      const schemaOffset = liquidContent.indexOf(schemaContent);
+
+      const visitor = await createJSONDocumentLinksVisitor(
+        textDocument,
+        URI.parse(rootUri),
+        schemaOffset,
+      );
+      const ast = toJSONAST(schemaContent);
+
+      if (ast instanceof Error) throw ast;
+      const result = await visit(ast, visitor);
+
+      // Should find both block type references (in blocks array and in presets)
+      expect(result).toHaveLength(2);
+      expect(result[0].target).toBe('file:///path/to/project/blocks/text.liquid');
+      expect(result[1].target).toBe('file:///path/to/project/blocks/text.liquid');
+    });
+
+    it('should not create links for special block types in schema tags', async () => {
+      uriString = 'file:///path/to/sections/app-blocks.liquid';
+      rootUri = 'file:///path/to/project';
+
+      const schemaContent = `
+        {
+          "name": "App Blocks",
+          "blocks": [
+            { "type": "@app" },
+            { "type": "@theme" },
+            { "type": "custom-block" }
+          ]
+        }
+      `;
+
+      const liquidContent = `
+        <div>App blocks section</div>
+        
+        {% schema %}
+        ${schemaContent}
+        {% endschema %}
+      `;
+
+      documentManager.open(uriString, liquidContent, 1);
+
+      const textDocument = documentManager.get(uriString)!.textDocument;
+      const schemaOffset = liquidContent.indexOf(schemaContent);
+      const visitor = await createJSONDocumentLinksVisitor(
+        textDocument,
+        URI.parse(rootUri),
+        schemaOffset,
+      );
+      const ast = toJSONAST(schemaContent);
+
+      if (ast instanceof Error) throw ast;
+      const result = await visit(ast, visitor);
+
+      // Should only create link for custom-block, not @app or @theme
+      expect(result).toHaveLength(1);
+      expect(result[0].target).toBe('file:///path/to/project/blocks/custom-block.liquid');
+    });
+  });
+
+  describe('JSON Files', () => {
+    it('should return document links for section types in template JSON files', async () => {
+      uriString = 'file:///path/to/templates/index.json';
+
+      const jsonContent = `{
+        "layout": "theme",
+        "sections": {
+          "header": {
+            "type": "header-section"
+          },
+          "main": {
+            "type": "main-product"
+          }
+        }
+      }`;
+
+      documentManager.open(uriString, jsonContent, 1);
+
+      const result = await jsonLanguageService.documentLinks({
+        textDocument: { uri: uriString },
+      });
+
+      expect(result).toHaveLength(2);
+      expect(result[0].target).toBe('file:///path/to/project/sections/header-section.liquid');
+      expect(result[1].target).toBe('file:///path/to/project/sections/main-product.liquid');
+    });
+
+    it('should return document links for block types in section JSON files', async () => {
+      uriString = 'file:///path/to/sections/settings.json';
+
+      const jsonContent = `{
+        "name": "Section with blocks",
+        "blocks": [
+          { "type": "text" },
+          { "type": "image" },
+          { "type": "@app" }
+        ]
+      }`;
+
+      documentManager.open(uriString, jsonContent, 1);
+
+      const result = await jsonLanguageService.documentLinks({
+        textDocument: { uri: uriString },
+      });
+
+      expect(result).toHaveLength(2);
+      expect(result[0].target).toBe('file:///path/to/project/blocks/text.liquid');
+      expect(result[1].target).toBe('file:///path/to/project/blocks/image.liquid');
+      // @app should not create a link
+    });
+  });
+});