@platformos/platformos-language-server-common 0.0.2

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

@@ -0,0 +1,524 @@
+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';
+
+describe('Module: ObjectAttributeCompletionProvider', async () => {
+  let provider: CompletionsProvider;
+  let settingsProvider: any;
+
+  beforeEach(async () => {
+    const _objects: ObjectEntry[] = [
+      {
+        name: 'settings',
+        properties: [],
+      },
+      {
+        name: 'global_default',
+        properties: [{ name: 'prop1' }, { name: 'prop2' }],
+      },
+      {
+        name: 'global_access',
+        access: {
+          global: true,
+          parents: [],
+          template: [],
+        },
+        properties: [{ name: 'prop3' }, { name: 'prop4' }],
+      },
+      {
+        name: 'product',
+        access: {
+          global: false,
+          parents: [],
+          template: ['product'],
+        },
+        properties: [
+          {
+            name: 'images',
+            return_type: [
+              {
+                type: 'array',
+                array_value: 'image',
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name: 'image',
+        access: {
+          global: false, // image is a type, but not a global variable
+          parents: [],
+          template: [],
+        },
+        properties: [
+          { name: 'src', return_type: [{ type: 'string', name: '' }] },
+          { name: 'width', return_type: [{ type: 'number', name: '' }] },
+          { name: 'height', return_type: [{ type: 'number', name: '' }] },
+        ],
+      },
+    ];
+
+    settingsProvider = vi.fn().mockResolvedValue([]);
+    provider = new CompletionsProvider({
+      documentManager: new DocumentManager(),
+      themeDocset: {
+        graphQL: async () => null,
+        filters: async () => [
+          { name: 'split', return_type: [{ type: 'array', array_value: 'string' }] },
+          { name: 'upcase', return_type: [{ type: 'string', name: '' }] },
+          { name: 'downcase', return_type: [{ type: 'string', name: '' }] },
+        ],
+        objects: async () => _objects,
+        liquidDrops: async () => _objects,
+        tags: async () => [],
+        systemTranslations: async () => ({}),
+      },
+      getThemeSettingsSchemaForURI: settingsProvider,
+      getMetafieldDefinitions: async (_rootUri: string) => ({} as MetafieldDefinitionMap),
+    });
+  });
+
+  it('does not complete number lookups', async () => {
+    await expect(provider).to.complete('{{ product[01█ }}', []);
+  });
+
+  it('does not complete boolean lookups', async () => {
+    await expect(provider).to.complete('{{ product[tr█ }}', []);
+  });
+
+  it('does complete string lookups', async () => {
+    await expect(provider).to.complete('{{ product["█ }}', ['images']);
+  });
+
+  it('has nothing to complete for numbers', async () => {
+    const sources = [
+      `{% assign x = 10 %}
+       {{ x.█ }}`,
+      `{% for x in (0..5) %}
+         {{ x.█ }}
+       {% endfor %}`,
+    ];
+    for (const source of sources) {
+      await expect(provider).to.complete(source, []);
+    }
+  });
+
+  describe('Case: global variables', () => {
+    it('returns the properties of global variables', async () => {
+      await expect(provider).to.complete('{{ global_default.█ }}', ['prop1', 'prop2']);
+      await expect(provider).to.complete('{{ global_access.█ }}', ['prop3', 'prop4']);
+    });
+
+    it('returns the properties of non-global variables that could be global per template', async () => {
+      await expect(provider).to.complete('{{ product.█ }}', ['images']);
+    });
+
+    it('does not complete the properties of a non-global type', async () => {
+      await expect(provider).to.complete('{{ image.█ }}', []);
+    });
+  });
+
+  describe('Case: scoping and inference', () => {
+    it('returns the properties of a resolved variable', async () => {
+      const source = `
+        {% assign x = global_default %}
+        {{ x.p█ }}
+      `;
+      await expect(provider).to.complete(source, ['prop1', 'prop2']);
+    });
+
+    it('returns the properties of the infered type of a deep lookup', async () => {
+      const source = `
+        {% assign x = product.images.first %}
+        {{ x.s█ }}
+      `;
+      await expect(provider).to.complete(source, ['src']);
+    });
+
+    it('returns the properties of the infered type of a series of threaded types', async () => {
+      const source = `
+        {% assign x = product %}
+        {% assign y = x.images %}
+        {% assign z = y.first %}
+        {{ z.s█ }}
+      `;
+      await expect(provider).to.complete(source, ['src']);
+    });
+
+    it('returns the properties of the infered type of a series of threaded types (liquid tag)', async () => {
+      const source = `
+        {% liquid
+          assign x = product
+          assign y = x.images
+          assign z = y.first
+          echo z.s█
+        %}
+      `;
+      await expect(provider).to.complete(source, ['src']);
+    });
+
+    describe('When: inside a for/tablerow loop', () => {
+      it('returns the properties of the array_value of the array', async () => {
+        for (const tag of ['for', 'tablerow']) {
+          const source = `
+            {% # x is global_default %}
+            {% assign x = global_default %}
+
+            {% # x is image only in for loop %}
+            {% ${tag} x in product.images %}
+              {{ x.s█ }}
+            {% end${tag} %}
+          `;
+          await expect(provider, source).to.complete(source, ['src']);
+        }
+      });
+    });
+
+    it('returns the properties of the last known type of a thing', async () => {
+      const source = `
+        {% # x is global_default %}
+        {% assign x = global_default %}
+
+        {% # x is image only in for loop %}
+        {% for x in product.images %}
+          {{ x.src }}
+        {% endfor %}
+
+        {% # x is still global_default %}
+        {{ x.█ }}
+      `;
+      await expect(provider).to.complete(source, ['prop1', 'prop2']);
+    });
+  });
+
+  describe('Case: capture', () => {
+    it('returns the properties of a captured string', async () => {
+      const source = `
+        {% capture x %}
+          ...
+        {% endcapture %}
+        {{ x.█ }}
+      `;
+      await expect(provider).to.complete(source, ['size']);
+    });
+  });
+
+  describe('Case: array parent type', () => {
+    it('returns the properties of a created array from filter', async () => {
+      const source = `
+        {% assign x = '123' | split: '' %}
+        {{ x.█ }}
+      `;
+      await expect(provider).to.complete(source, ['first', 'last', 'size']);
+    });
+
+    it('returns the properties of the array_value', async () => {
+      const sources = [
+        `{% assign x = product.images %}
+         {{ x.first.█ }}`,
+        `{% assign x = product.images %}
+         {{ x.last.█ }}`,
+        `{% assign x = product.images %}
+         {{ x[0].█ }}`,
+        `{% assign x = product.images %}
+         {{ x[1].█ }}`,
+        `{% assign x = product.images %}
+         {% assign lookup = 0 %}
+         {{ x[lookup].█ }}`,
+      ];
+      for (const source of sources) {
+        await expect(provider, source).to.complete(source, ['height', 'src', 'width']);
+      }
+    });
+  });
+
+  describe('Case: infered filter return type', () => {
+    it('should return the properties of a string return type', async () => {
+      const source = `
+        {% assign x = product.images.first.src | upcase | downcase %}
+        {{ x.█ }}
+      `;
+      await expect(provider).to.complete(source, ['size']);
+    });
+
+    it('should return the properties of an array return type', async () => {
+      const source = `
+        {% assign x = product.images.first.src | split: ',' %}
+        {{ x.█ }}
+      `;
+      await expect(provider).to.complete(source, ['first', 'last', 'size']);
+    });
+  });
+
+  describe('Case: parse_json filter with arrays', () => {
+    it('should complete properties of array elements accessed by index', async () => {
+      const source = `
+        {% assign a = '[{"name": "foo"}, {"name": "bar"}]' | parse_json %}
+        {{ a[0].█ }}
+      `;
+      await expect(provider).to.complete(source, ['name']);
+    });
+
+    it('should complete properties of array elements accessed with first/last', async () => {
+      const sources = [
+        `{% assign a = '[{"prop": 1}]' | parse_json %}
+         {{ a.first.█ }}`,
+        `{% assign a = '[{"prop": 1}]' | parse_json %}
+         {{ a.last.█ }}`,
+      ];
+      for (const source of sources) {
+        await expect(provider, source).to.complete(source, ['prop']);
+      }
+    });
+
+    it('should complete properties of nested objects in arrays', async () => {
+      const source = `
+        {% assign a = '[{"user": {"id": 1, "name": "test"}}]' | parse_json %}
+        {{ a[0].user.█ }}
+      `;
+      await expect(provider).to.complete(source, ['id', 'name']);
+    });
+
+    it('should complete array properties for JSON arrays', async () => {
+      const source = `
+        {% assign a = '[1, 2, 3]' | parse_json %}
+        {{ a.█ }}
+      `;
+      await expect(provider).to.complete(source, ['first', 'last', 'size']);
+    });
+
+    it('should work with to_hash filter', async () => {
+      const source = `
+        {% assign a = '{"key": "value"}' | to_hash %}
+        {{ a.█ }}
+      `;
+      await expect(provider).to.complete(source, ['key']);
+    });
+
+    it('should complete properties added via hash_assign to parse_json object', async () => {
+      const source = `
+        {% assign a = '{}' | parse_json %}
+        {% hash_assign a['key'] = 5 %}
+        {{ a.█ }}
+      `;
+      await expect(provider).to.complete(source, ['key']);
+    });
+
+    it('should complete properties added via hash_assign to existing parse_json object', async () => {
+      const source = `
+        {% assign a = '{"existing": 1}' | parse_json %}
+        {% hash_assign a['added'] = 2 %}
+        {{ a.█ }}
+      `;
+      await expect(provider).to.complete(source, ['added', 'existing']);
+    });
+
+    it('should complete nested properties added via hash_assign', async () => {
+      const source = `
+        {% assign a = '{}' | parse_json %}
+        {% hash_assign a['nested'] = '{}' | parse_json %}
+        {% hash_assign a['nested']['key'] = 5 %}
+        {{ a.nested.█ }}
+      `;
+      await expect(provider).to.complete(source, ['key']);
+    });
+
+    it('should complete first level with nested hash_assign', async () => {
+      const source = `
+        {% assign a = '{}' | parse_json %}
+        {% hash_assign a['nested'] = '{}' | parse_json %}
+        {% hash_assign a['nested']['key'] = 5 %}
+        {{ a.█ }}
+      `;
+      await expect(provider).to.complete(source, ['nested']);
+    });
+
+    it('should merge shapes from all array elements', async () => {
+      const source = `
+        {% assign a = '[{"name": "foo"}, {"age": 30}, {"name": "bar", "city": "NYC"}]' | parse_json %}
+        {{ a[0].█ }}
+      `;
+      await expect(provider).to.complete(source, ['age', 'city', 'name']);
+    });
+
+    it('should infer shape from default filter value', async () => {
+      const source = `
+        {% assign a = some_var | default: '{"fallback": true, "value": 42}' | parse_json %}
+        {{ a.█ }}
+      `;
+      await expect(provider).to.complete(source, ['fallback', 'value']);
+    });
+
+    it('should work with parse_json block syntax', async () => {
+      const source = `
+        {% parse_json data %}
+          {"name": "test", "count": 5}
+        {% endparse_json %}
+        {{ data.█ }}
+      `;
+      await expect(provider).to.complete(source, ['count', 'name']);
+    });
+
+    it('should handle variable reassignment', async () => {
+      const source = `
+        {% assign a = '{"old": 1}' | parse_json %}
+        {% assign a = '{"new": 2}' | parse_json %}
+        {{ a.█ }}
+      `;
+      await expect(provider).to.complete(source, ['new']);
+    });
+
+    it('should handle hash_assign without lookups (works like assign)', async () => {
+      const source = `
+        {% hash_assign a = '{"key": "value"}' | parse_json %}
+        {{ a.█ }}
+      `;
+      await expect(provider).to.complete(source, ['key']);
+    });
+
+    it('should handle hash_assign reassignment without lookups', async () => {
+      const source = `
+        {% assign a = '{"old": 1}' | parse_json %}
+        {% hash_assign a = '{"new": 2}' | parse_json %}
+        {{ a.█ }}
+      `;
+      await expect(provider).to.complete(source, ['new']);
+    });
+
+    it('should handle parse_json block tag reassignment', async () => {
+      const source = `
+        {% assign a = '{"old": 1}' | parse_json %}
+        {% parse_json a %}{"new": 2}{% endparse_json %}
+        {{ a.█ }}
+      `;
+      await expect(provider).to.complete(source, ['new']);
+    });
+
+    it('should include type information in completion detail', async () => {
+      const source = `
+        {% assign a = '{"name": "foo", "count": 5, "active": true, "items": [1, 2]}' | parse_json %}
+        {{ a.█ }}
+      `;
+      await expect(provider).to.complete(source, [
+        expect.objectContaining({
+          label: 'active',
+          detail: 'Type: boolean',
+          kind: CompletionItemKind.Property,
+        }),
+        expect.objectContaining({
+          label: 'count',
+          detail: 'Type: number',
+          kind: CompletionItemKind.Property,
+        }),
+        expect.objectContaining({
+          label: 'items',
+          detail: 'Type: number[]',
+          kind: CompletionItemKind.Property,
+        }),
+        expect.objectContaining({
+          label: 'name',
+          detail: 'Type: string',
+          kind: CompletionItemKind.Property,
+        }),
+      ]);
+    });
+
+    it('should show object type with keys for nested objects', async () => {
+      const source = `
+        {% assign a = '{"user": {"id": 1, "name": "test"}}' | parse_json %}
+        {{ a.█ }}
+      `;
+      await expect(provider).to.complete(source, [
+        expect.objectContaining({
+          label: 'user',
+          detail: 'Type: object\nKeys: id, name',
+          kind: CompletionItemKind.Property,
+        }),
+      ]);
+    });
+
+    it('should show correct type for array first/last accessors with item keys', async () => {
+      const source = `
+        {% assign a = '[{"name": "test", "id": 1}]' | parse_json %}
+        {{ a.█ }}
+      `;
+      await expect(provider).to.complete(source, [
+        expect.objectContaining({
+          label: 'first',
+          detail: 'Type: object\nKeys: name, id',
+          kind: CompletionItemKind.Property,
+        }),
+        expect.objectContaining({
+          label: 'last',
+          detail: 'Type: object\nKeys: name, id',
+          kind: CompletionItemKind.Property,
+        }),
+        expect.objectContaining({
+          label: 'size',
+          detail: 'Type: number',
+          kind: CompletionItemKind.Property,
+        }),
+      ]);
+    });
+
+    it('should truncate keys when there are many', async () => {
+      const source = `
+        {% assign a = '{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7}' | parse_json %}
+        {{ a.█ }}
+      `;
+      // Check that one of the completions has truncated keys
+      await expect(provider).to.complete(
+        source,
+        expect.arrayContaining([
+          expect.objectContaining({
+            label: 'a',
+            detail: 'Type: number',
+          }),
+        ]),
+      );
+    });
+
+    it('should complete properties when referencing variable in its own reassignment', async () => {
+      const source = `
+        {% assign a = '{"foo": 1, "bar": 2}' | parse_json %}
+        {% assign a = a.█ %}
+      `;
+      await expect(provider).to.complete(source, ['bar', 'foo']);
+    });
+
+    it('should complete nested properties in self-referential assignment', async () => {
+      const source = `
+        {% assign a = '{"nested": {"deep": 1}}' | parse_json %}
+        {% assign b = a.nested.█ %}
+      `;
+      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/ObjectAttributeCompletionProvider.ts

@@ -0,0 +1,95 @@
+import { NodeTypes } from '@platformos/liquid-html-parser';
+import { ObjectEntry } from '@platformos/platformos-check-common';
+import { CompletionItem, CompletionItemKind } from 'vscode-languageserver';
+import { TypeSystem, isArrayType, isShapeType, isUnionType } from '../../TypeSystem';
+import { CURSOR, LiquidCompletionParams } from '../params';
+import { Provider, createCompletionItem, sortByName } from './common';
+import { getAvailablePropertiesWithTypes } from '../../PropertyShapeInference';
+
+const ArrayCoreProperties = ['size', 'first', 'last'] as const;
+const StringCoreProperties = ['size'] as const;
+
+export class ObjectAttributeCompletionProvider implements Provider {
+  constructor(private readonly typeSystem: TypeSystem) {}
+
+  async completions(params: LiquidCompletionParams): Promise<CompletionItem[]> {
+    if (!params.completionContext) return [];
+
+    const { partialAst, node } = params.completionContext;
+    if (!node || node.type !== NodeTypes.VariableLookup) {
+      return [];
+    }
+
+    if (node.lookups.length === 0) {
+      // We only do lookups in this one
+      return [];
+    }
+
+    const lastLookup = node.lookups.at(-1)!;
+    if (lastLookup.type !== NodeTypes.String) {
+      // We don't complete numbers, or variable lookups
+      return [];
+    }
+
+    const partial = lastLookup.value.replace(CURSOR, '');
+
+    // Fake a VariableLookup up to the last one.
+    const parentLookup = { ...node };
+    parentLookup.lookups = [...parentLookup.lookups];
+    parentLookup.lookups.pop();
+    const parentType = await this.typeSystem.inferType(
+      parentLookup,
+      partialAst,
+      params.textDocument.uri,
+    );
+
+    if (isArrayType(parentType)) {
+      return completionItems(
+        ArrayCoreProperties.map((name) => ({ name })),
+        partial,
+      );
+    }
+
+    if (parentType === 'string') {
+      return completionItems(
+        StringCoreProperties.map((name) => ({ name })),
+        partial,
+      );
+    }
+
+    if (isShapeType(parentType)) {
+      // Handle ShapeType from parse_json, graphql, hash_assign
+      const shapeCompletions = getAvailablePropertiesWithTypes(parentType.shape);
+      return shapeCompletions
+        .filter((prop) => prop.name.startsWith(partial))
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map((prop) =>
+          createCompletionItem(
+            { name: prop.name },
+            { kind: CompletionItemKind.Property, detail: prop.detail },
+          ),
+        );
+    }
+
+    // UnionType doesn't have direct property completions
+    if (isUnionType(parentType)) {
+      return [];
+    }
+
+    const objectMap = await this.typeSystem.objectMap(params.textDocument.uri, partialAst);
+    const parentTypeProperties = objectMap[parentType]?.properties || [];
+
+    return completionItems(parentTypeProperties, partial);
+  }
+}
+
+function completionItems(options: ObjectEntry[], partial: string) {
+  return options
+    .filter(({ name }) => name.startsWith(partial))
+    .sort(sortByName)
+    .map(toPropertyCompletionItem);
+}
+
+function toPropertyCompletionItem(object: ObjectEntry) {
+  return createCompletionItem(object, { kind: CompletionItemKind.Variable });
+}