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

package/src/TypeSystem.ts

@@ -23,33 +23,26 @@ import {
   ArrayReturnType,
   DocsetEntry,
   FilterEntry,
-  MetafieldDefinitionMap,
-  MetafieldDefinition,
   ObjectEntry,
   ReturnType,
   SourceCodeType,
-  ThemeDocset,
+  PlatformOSDocset,
   isError,
   parseJSON,
   path,
-  FETCHED_METAFIELD_CATEGORIES,
   BasicParamTypes,
   getValidParamTypes,
   parseParamType,
 } from '@platformos/platformos-check-common';
-import {
-  GetThemeSettingsSchemaForURI,
-  InputSetting,
-  isInputSetting,
-  isSettingsCategory,
-} from './settings';
 import { findLast, memo } from './utils';
 import { visit } from '@platformos/platformos-check-common';
 import {
   PropertyShape,
   inferShapeFromJSONString,
+  inferShapeFromJsonLiteral,
   inferShapeFromGraphQL,
   lookupPropertyPath,
+  mergeShapes,
   shapeToTypeString,
   shapeToDetailString,
 } from './PropertyShapeInference';
@@ -61,17 +54,15 @@ export class TypeSystem {
   private graphqlSchemaLoaded = false;
 
   constructor(
-    private readonly themeDocset: ThemeDocset,
-    private readonly getThemeSettingsSchemaForURI: GetThemeSettingsSchemaForURI,
-    private readonly getMetafieldDefinitions: (rootUri: string) => Promise<MetafieldDefinitionMap>,
+    private readonly platformosDocset: PlatformOSDocset,
     private readonly fs?: AbstractFileSystem,
     private readonly documentsLocator?: DocumentsLocator,
-    private readonly findThemeRootURI?: (uri: string) => Promise<string | null>,
+    private readonly findAppRootURI?: (uri: string) => Promise<string | null>,
   ) {}
 
   private async getGraphQLSchema(): Promise<string | undefined> {
     if (!this.graphqlSchemaLoaded) {
-      this.graphqlSchemaCache = (await this.themeDocset.graphQL()) ?? undefined;
+      this.graphqlSchemaCache = (await this.platformosDocset.graphQL()) ?? undefined;
       this.graphqlSchemaLoaded = true;
     }
     return this.graphqlSchemaCache;
@@ -125,174 +116,15 @@ export class TypeSystem {
       });
   }
 
-  public async themeSettingProperties(uri: string): Promise<ObjectEntry[]> {
-    const themeSettingsSchema = await this.getThemeSettingsSchemaForURI(uri);
-    const categories = themeSettingsSchema.filter(isSettingsCategory);
-    const result: ObjectEntry[] = [];
-    for (const category of categories) {
-      const inputSettings = category.settings.filter(isInputSetting);
-      for (const setting of inputSettings) {
-        result.push({
-          name: setting.id,
-          summary: '', // TODO, this should lookup the locale file for settings... setting.label
-          description: '', // TODO , this should lookup the locale file as well... setting.info,
-          return_type: settingReturnType(setting),
-          access: {
-            global: false,
-            parents: [],
-            template: [],
-          },
-        });
-      }
-    }
-    return result;
-  }
-
   /**
    * An indexed representation of objects.json by name
    *
    * e.g. objectMap['product'] returns the product ObjectEntry.
    */
   public objectMap = async (uri: string, ast: LiquidHtmlNode): Promise<ObjectMap> => {
-    const [objectMap, themeSettingProperties, metafieldDefinitionsObjectMap] = await Promise.all([
-      this._objectMap(),
-      this.themeSettingProperties(uri),
-      this.metafieldDefinitionsObjectMap(uri),
-    ]);
-
-    // Here we shallow mutate `settings.properties` to have the properties made
-    // available by settings_schema.json
-    const result: ObjectMap = {
-      ...objectMap,
-      settings: {
-        ...(objectMap.settings ?? {}),
-        properties: themeSettingProperties,
-      },
-      ...customMetafieldTypeEntries(objectMap['metafield']),
-      ...metafieldDefinitionsObjectMap,
-    };
-
-    // For each metafield definition fetched, we need to override existing types with `metafields` property
-    // to `${category}_metafield`.
-    //
-    // WARNING: Since we aren't cloning the object, we are mutating the original type for all themes in
-    // the workspace. However, this is fine since these changes are not unique to a theme.
-    for (let category of FETCHED_METAFIELD_CATEGORIES) {
-      if (!result[category]) continue;
-
-      let metafieldsProperty = result[category].properties?.find(
-        (prop) => prop.name === 'metafields',
-      );
-
-      if (!metafieldsProperty) continue;
-
-      metafieldsProperty.return_type = [{ type: `${category}_metafields`, name: '' }];
-    }
-
-    // Deal with sections/file.liquid section.settings by infering the type from the {% schema %}
-    if (/[\/\\]sections[\/\\]/.test(uri) && result.section) {
-      result.section = JSON.parse(JSON.stringify(result.section)); // easy deep clone
-      const settings = result.section.properties?.find((x) => x.name === 'settings');
-      if (!settings || !settings.return_type) return result;
-      settings.return_type = [{ type: 'section_settings', name: '' }];
-      result.section_settings = {
-        name: 'section_settings',
-        access: {
-          global: false,
-          parents: [],
-          template: [],
-        },
-        properties: schemaSettingsAsProperties(ast),
-        return_type: [],
-      };
-    }
-
-    // Deal with blocks/files.liquid block.settings in a similar fashion
-    if (/[\/\\]blocks[\/\\]/.test(uri) && result.block) {
-      result.block = JSON.parse(JSON.stringify(result.block)); // easy deep clone
-      const settings = result.block.properties?.find((x) => x.name === 'settings');
-      if (!settings || !settings.return_type) return result;
-      settings.return_type = [{ type: 'block_settings', name: '' }];
-      result.block_settings = {
-        name: 'block_settings',
-        access: {
-          global: false,
-          parents: [],
-          template: [],
-        },
-        properties: schemaSettingsAsProperties(ast),
-        return_type: [],
-      };
-    }
-
-    return result;
+    return this._objectMap();
   };
 
-  public async metafieldDefinitionsObjectMap(uri: string): Promise<ObjectMap> {
-    let result: ObjectMap = {};
-
-    const metafieldDefinitionMap = await this.getMetafieldDefinitions(uri);
-
-    for (let [category, definitions] of Object.entries(metafieldDefinitionMap)) {
-      // Metafield definitions need to be grouped by their namespace
-      let metafieldNamespaces = new Map<string, ObjectEntry[]>();
-
-      for (let definition of definitions as MetafieldDefinition[]) {
-        if (!metafieldNamespaces.has(definition.namespace)) {
-          metafieldNamespaces.set(definition.namespace, []);
-        }
-
-        metafieldNamespaces.get(definition.namespace)!.push({
-          name: definition.key,
-          description: definition.description,
-          return_type: metafieldReturnType(definition.type.name),
-        });
-      }
-
-      let metafieldGroupProperties: ObjectEntry[] = [];
-
-      for (let [namespace, namespaceProperties] of metafieldNamespaces) {
-        const metafieldCategoryNamespaceHandle = `${category}_metafield_${namespace}`;
-
-        // Since the namespace can be shared by multiple categories, we need to make sure the return_type
-        // handle is unique across all categories
-        metafieldGroupProperties.push({
-          name: namespace,
-          return_type: [{ type: metafieldCategoryNamespaceHandle, name: '' }],
-          access: {
-            global: false,
-            parents: [],
-            template: [],
-          },
-        });
-
-        result[metafieldCategoryNamespaceHandle] = {
-          name: metafieldCategoryNamespaceHandle,
-          properties: namespaceProperties,
-          access: {
-            global: false,
-            parents: [],
-            template: [],
-          },
-        };
-      }
-
-      const metafieldCategoryHandle = `${category}_metafields`;
-
-      result[metafieldCategoryHandle] = {
-        name: metafieldCategoryHandle,
-        properties: metafieldGroupProperties,
-        access: {
-          global: false,
-          parents: [],
-          template: [],
-        },
-      };
-    }
-
-    return result;
-  }
-
   // This is the big one we reuse (memoized)
   private _objectMap = memo(async (): Promise<ObjectMap> => {
     const entries = await this.objectEntries();
@@ -312,20 +144,20 @@ export class TypeSystem {
   });
 
   public filterEntries = memo(async () => {
-    return this.themeDocset.filters();
+    return this.platformosDocset.filters();
   });
 
   public objectEntries = memo(async () => {
-    return this.themeDocset.objects();
+    return this.platformosDocset.objects();
   });
 
   private async symbolsTable(partialAst: LiquidHtmlNode, uri: string): Promise<SymbolsTable> {
     const [seedSymbolsTable, liquidDrops, graphqlSchema, rootUri, objectMap, filtersMap] =
       await Promise.all([
         this.seedSymbolsTable(uri),
-        this.themeDocset.liquidDrops(),
+        this.platformosDocset.liquidDrops(),
         this.getGraphQLSchema(),
-        this.findThemeRootURI?.(uri) ?? null,
+        this.findAppRootURI?.(uri) ?? null,
         this.objectMap(uri, partialAst),
         this.filtersMap(),
       ]);
@@ -382,36 +214,10 @@ export class TypeSystem {
   };
 }
 
-const SECTION_FILE_REGEX = /sections[\/\\][^.\\\/]*\.liquid$/;
-const BLOCK_FILE_REGEX = /blocks[\/\\][^.\\\/]*\.liquid$/;
 const PARTIAL_FILE_REGEX = /(views[\/\\]partials[\/\\]|[\/\\]lib[\/\\])[^.]*\.liquid$/;
-const LAYOUT_FILE_REGEX = /layout[\/\\]checkout\.liquid$/;
 
 function getContextualEntries(uri: string): string[] {
   const normalizedUri = path.normalize(uri);
-  if (LAYOUT_FILE_REGEX.test(normalizedUri)) {
-    return [
-      'locale',
-      'direction',
-      'skip_to_content_link',
-      'checkout_html_classes',
-      'checkout_stylesheets',
-      'checkout_scripts',
-      'content_for_logo',
-      'breadcrumb',
-      'order_summary_toggle',
-      'content_for_order_summary',
-      'alternative_payment_methods',
-      'content_for_footer',
-      'tracking_code',
-    ];
-  }
-  if (SECTION_FILE_REGEX.test(normalizedUri)) {
-    return ['section', 'predictive_search', 'recommendations', 'comment'];
-  }
-  if (BLOCK_FILE_REGEX.test(normalizedUri)) {
-    return ['app', 'section', 'recommendations', 'block'];
-  }
   if (PARTIAL_FILE_REGEX.test(normalizedUri)) {
     return ['app'];
   }
@@ -574,51 +380,202 @@ async function buildSymbolsTable(
   const typeRanges = await visit<SourceCodeType.LiquidHtml, TypeRange | TypeRange[]>(partialAst, {
     // {% assign x = foo.x | filter %}
     // {% assign x = '{"a": 1}' | parse_json %}
+    // {% assign x = {a: 1, b: "hello"} %}
+    // {% assign x["key"] = value %}
+    // {% assign arr << item %}
     async AssignMarkup(node) {
-      // Check if this has a parse_json or to_hash filter
-      const hasParseJsonFilter = node.value.filters?.some(
-        (f: { name: string }) => f.name === 'parse_json' || f.name === 'to_hash',
-      );
+      const expression = node.value.expression;
+      let valueShape: PropertyShape | undefined;
+
+      // Resolver for variable references inside JSON literals
+      const resolveExpr = (expr: LiquidExpression): PropertyShape | undefined => {
+        if (expr.type !== NodeTypes.VariableLookup || !expr.name) return undefined;
+
+        // Look up the variable's shape from already-processed assignments
+        const shapes = variableShapes.get(expr.name);
+        const shapeEntry = shapes
+          ? findLastApplicableShape(shapes, node.position.start)
+          : undefined;
+        let shape = shapeEntry?.shape;
+
+        // Fall back to seedSymbolsTable
+        if (!shape && seedSymbolsTable[expr.name]) {
+          for (const tr of seedSymbolsTable[expr.name]) {
+            if (tr.range[0] < node.position.start) {
+              if (typeof tr.type !== 'string' && tr.type.kind === 'shape') {
+                shape = tr.type.shape;
+              } else if (typeof tr.type === 'string' || tr.type.kind === 'array') {
+                shape = resolvedTypeToShape(tr.type);
+              }
+            }
+          }
+        }
 
-      if (hasParseJsonFilter) {
-        let jsonString: string | undefined;
+        if (!shape) return undefined;
 
-        // Check if expression is a direct JSON string
-        if (node.value.expression.type === NodeTypes.String) {
-          jsonString = node.value.expression.value;
+        // Resolve lookups (e.g. a.x or a["key"])
+        for (const lookup of expr.lookups) {
+          if (shape.kind === 'object' && lookup.type === NodeTypes.String && shape.properties) {
+            const prop = shape.properties.get(lookup.value);
+            if (prop) {
+              shape = prop;
+            } else {
+              return undefined;
+            }
+          } else if (shape.kind === 'array') {
+            if (
+              lookup.type === NodeTypes.Number ||
+              (lookup.type === NodeTypes.String &&
+                (lookup.value === 'first' || lookup.value === 'last'))
+            ) {
+              shape = shape.itemShape;
+              if (!shape) return undefined;
+            } else {
+              return undefined;
+            }
+          } else {
+            return undefined;
+          }
         }
 
-        // Check if there's a default filter with a JSON string argument
-        if (!jsonString && node.value.filters) {
-          const defaultFilter = node.value.filters.find(
-            (f: { name: string }) => f.name === 'default',
-          );
-          if (defaultFilter && defaultFilter.args && defaultFilter.args.length > 0) {
-            const firstArg = defaultFilter.args[0];
-            if (firstArg.type === NodeTypes.String) {
-              jsonString = firstArg.value;
+        return shape;
+      };
+
+      // Case 1: JSON literal expression
+      if (
+        expression.type === NodeTypes.JsonHashLiteral ||
+        expression.type === NodeTypes.JsonArrayLiteral
+      ) {
+        valueShape = inferShapeFromJsonLiteral(expression, resolveExpr);
+      }
+
+      // Case 2: parse_json / to_hash filter on a string
+      if (!valueShape) {
+        const hasParseJsonFilter = node.value.filters?.some(
+          (f: { name: string }) => f.name === 'parse_json' || f.name === 'to_hash',
+        );
+        if (hasParseJsonFilter) {
+          let jsonString: string | undefined;
+          if (expression.type === NodeTypes.String) {
+            jsonString = expression.value;
+          }
+          if (!jsonString && node.value.filters) {
+            const defaultFilter = node.value.filters.find(
+              (f: { name: string }) => f.name === 'default',
+            );
+            if (
+              defaultFilter &&
+              defaultFilter.args &&
+              defaultFilter.args.length > 0 &&
+              defaultFilter.args[0].type === NodeTypes.String
+            ) {
+              jsonString = defaultFilter.args[0].value;
             }
           }
+          if (jsonString) {
+            valueShape = inferShapeFromJSONString(jsonString) ?? undefined;
+          }
         }
+      }
 
-        if (jsonString) {
-          const shape = inferShapeFromJSONString(jsonString);
-          if (shape) {
-            // Track shape for potential hash_assign merging
-            if (!variableShapes.has(node.name)) {
-              variableShapes.set(node.name, []);
-            }
-            variableShapes.get(node.name)!.push({ shape, rangeEnd: node.position.end });
+      // Case 3: Infer primitive shape for << and LHS lookup scenarios
+      if (!valueShape && ((node.lookups && node.lookups.length > 0) || node.operator === '<<')) {
+        if (expression.type === NodeTypes.String) {
+          valueShape = { kind: 'primitive', primitiveType: 'string' };
+        } else if (expression.type === NodeTypes.Number) {
+          valueShape = { kind: 'primitive', primitiveType: 'number' };
+        } else if (expression.type === NodeTypes.LiquidLiteral) {
+          if (expression.value === null) {
+            valueShape = { kind: 'primitive', primitiveType: 'null' };
+          } else if (typeof expression.value === 'boolean') {
+            valueShape = { kind: 'primitive', primitiveType: 'boolean' };
+          }
+        }
+      }
 
-            return {
-              identifier: node.name,
-              type: shapeType(shape),
-              range: [node.position.end],
-            };
+      // Handle lookups on the LHS (assign x["key"] = value)
+      if (node.lookups && node.lookups.length > 0) {
+        const lookupPath = getAssignLookupPath(node.lookups);
+        if (lookupPath && lookupPath.length > 0) {
+          const existingShapes = variableShapes.get(node.name) || [];
+          const existingShapeEntry = findLastApplicableShape(existingShapes, node.position.start);
+
+          let baseShape: PropertyShape;
+          if (existingShapeEntry) {
+            baseShape = existingShapeEntry.shape;
+          } else {
+            let existingType: PseudoType | ArrayType | ShapeType | UnionType | undefined;
+            if (seedSymbolsTable[node.name]) {
+              for (const tr of seedSymbolsTable[node.name]) {
+                if (tr.range[0] < node.position.start) {
+                  if (typeof tr.type !== 'string' && tr.type.kind === 'shape') {
+                    existingType = tr.type;
+                  }
+                }
+              }
+            }
+            baseShape =
+              existingType && isShapeType(existingType)
+                ? existingType.shape
+                : { kind: 'object', properties: new Map() };
           }
+
+          const newShape = mergeNestedPropertyIntoShape(
+            baseShape,
+            lookupPath,
+            valueShape ?? { kind: 'primitive' },
+          );
+
+          if (!variableShapes.has(node.name)) variableShapes.set(node.name, []);
+          variableShapes.get(node.name)!.push({ shape: newShape, rangeEnd: node.position.end });
+
+          return {
+            identifier: node.name,
+            type: shapeType(newShape),
+            range: [node.position.end],
+          };
+        }
+      }
+
+      // Handle << operator (array append)
+      if (node.operator === '<<') {
+        const itemShape: PropertyShape = valueShape ?? { kind: 'primitive' };
+        const existingShapes = variableShapes.get(node.name) || [];
+        const existingShapeEntry = findLastApplicableShape(existingShapes, node.position.start);
+
+        let arrayShape: PropertyShape;
+        if (existingShapeEntry?.shape.kind === 'array') {
+          const existing = existingShapeEntry.shape.itemShape;
+          arrayShape = {
+            kind: 'array',
+            itemShape: existing ? mergeShapes(existing, itemShape) : itemShape,
+          };
+        } else {
+          arrayShape = { kind: 'array', itemShape };
         }
+
+        if (!variableShapes.has(node.name)) variableShapes.set(node.name, []);
+        variableShapes.get(node.name)!.push({ shape: arrayShape, rangeEnd: node.position.end });
+
+        return {
+          identifier: node.name,
+          type: shapeType(arrayShape),
+          range: [node.position.end],
+        };
       }
 
+      // Simple assignment with shape (JSON literal or parse_json)
+      if (valueShape) {
+        if (!variableShapes.has(node.name)) variableShapes.set(node.name, []);
+        variableShapes.get(node.name)!.push({ shape: valueShape, rangeEnd: node.position.end });
+        return {
+          identifier: node.name,
+          type: shapeType(valueShape),
+          range: [node.position.end],
+        };
+      }
+
+      // Default: lazy variable type
       return {
         identifier: node.name,
         type: lazyVariable(node.value, node.position.start),
@@ -657,12 +614,6 @@ async function buildSymbolsTable(
           type: String,
           range: [node.position.end],
         };
-      } else if (['form', 'paginate'].includes(node.name)) {
-        return {
-          identifier: node.name,
-          type: node.name,
-          range: [node.blockStartPosition.end, end(node.blockEndPosition?.end)],
-        };
       } else if (['for', 'tablerow'].includes(node.name)) {
         return {
           identifier: node.name + 'loop',
@@ -1022,6 +973,16 @@ function inferType(
       return arrayType('number');
     }
 
+    // JSON literal expressions: {key: val} or [1, 2, 3]
+    case NodeTypes.JsonHashLiteral:
+    case NodeTypes.JsonArrayLiteral: {
+      const resolver = (expr: LiquidExpression): PropertyShape | undefined => {
+        const type = inferType(expr, symbolsTable, objectMap, filtersMap);
+        return resolvedTypeToShape(type);
+      };
+      return shapeType(inferShapeFromJsonLiteral(thing, resolver));
+    }
+
     // The type of the assign markup is the type of the right hand side.
     // {% assign x = y.property | filter1 | filter2 %}
     case NodeTypes.AssignMarkup: {
@@ -1346,6 +1307,36 @@ function shapeToType(shape: PropertyShape): PseudoType | ArrayType | ShapeType {
   return Untyped;
 }
 
+/**
+ * Convert a resolved type back to a PropertyShape (inverse of shapeToType).
+ * Used when embedding resolved variable types into JSON literal shapes.
+ */
+function resolvedTypeToShape(
+  type: PseudoType | ArrayType | ShapeType | UnionType,
+): PropertyShape | undefined {
+  if (typeof type === 'string') {
+    switch (type) {
+      case 'string':
+        return { kind: 'primitive', primitiveType: 'string' };
+      case 'number':
+        return { kind: 'primitive', primitiveType: 'number' };
+      case 'boolean':
+        return { kind: 'primitive', primitiveType: 'boolean' };
+      case Untyped:
+      case Unknown:
+        return undefined;
+      default:
+        return { kind: 'primitive' };
+    }
+  }
+  if (isShapeType(type)) return type.shape;
+  if (isArrayType(type)) {
+    const itemShape = resolvedTypeToShape(type.valueType);
+    return { kind: 'array', itemShape };
+  }
+  return undefined;
+}
+
 function inferPseudoTypePropertyType(
   curr: PseudoType, // settings
   lookup: LiquidExpression,
@@ -1656,6 +1647,24 @@ export function typeToDisplayString(type: PseudoType | ArrayType | ShapeType | U
   return 'unknown';
 }
 
+/**
+ * Extract the lookup path from assign lookups.
+ * For {% assign a["key1"]["key2"] = value %}, returns ['key1', 'key2']
+ */
+function getAssignLookupPath(lookups: LiquidExpression[]): string[] | undefined {
+  const path: string[] = [];
+  for (const lookup of lookups) {
+    if (lookup.type === NodeTypes.String) {
+      path.push(lookup.value);
+    } else if (lookup.type === NodeTypes.Number) {
+      path.push(`${lookup.value}`);
+    } else {
+      return undefined;
+    }
+  }
+  return path.length > 0 ? path : undefined;
+}
+
 /**
  * Extract the lookup path from a hash_assign target.
  * For {% hash_assign a['key1']['key2'] = value %}, returns ['key1', 'key2']
@@ -1731,218 +1740,3 @@ function findLastApplicableShape(
   }
   return result;
 }
-
-function settingReturnType(setting: InputSetting): ObjectEntry['return_type'] {
-  switch (setting.type) {
-    // basic settings
-    case 'checkbox':
-      return [{ type: 'boolean', name: '' }];
-
-    case 'range':
-    case 'number':
-      return [{ type: 'number', name: '' }];
-
-    case 'radio':
-    case 'select':
-    case 'text':
-    case 'textarea':
-      return [{ type: 'string', name: '' }];
-
-    // specialized settings
-    case 'article':
-      return [{ type: 'article', name: '' }];
-
-    case 'blog':
-      return [{ type: 'blog', name: '' }];
-
-    case 'collection':
-      return [{ type: 'collection', name: '' }];
-
-    case 'collection_list':
-      return [{ type: 'array', array_value: 'collection' }];
-
-    case 'color':
-      return [{ type: 'color', name: '' }];
-
-    case 'color_background':
-      return [{ type: 'string', name: '' }];
-
-    case 'color_scheme':
-      return [{ type: 'color_scheme', name: '' }];
-
-    // TODO ??
-    case 'color_scheme_group':
-      return [];
-
-    case 'font_picker':
-      return [{ type: 'font', name: '' }];
-
-    case 'html':
-      return [{ type: 'string', name: '' }];
-
-    case 'image_picker':
-      return [{ type: 'image', name: '' }];
-
-    case 'inline_richtext':
-      return [{ type: 'string', name: '' }];
-
-    case 'link_list':
-      return [{ type: 'linklist', name: '' }];
-
-    case 'liquid':
-      return [{ type: 'string', name: '' }];
-
-    case 'page':
-      return [{ type: 'page', name: '' }];
-
-    case 'product':
-      return [{ type: 'product', name: '' }];
-
-    case 'product_list':
-      return [{ type: 'array', array_value: 'product' }];
-
-    case 'richtext':
-      return [{ type: 'string', name: '' }];
-
-    case 'text_alignment':
-      return [{ type: 'string', name: '' }];
-
-    case 'url':
-      return [{ type: 'string', name: '' }];
-
-    case 'video':
-      return [{ type: 'video', name: '' }];
-
-    case 'video_url':
-      return [{ type: 'string', name: '' }];
-
-    default:
-      return [];
-  }
-}
-
-const METAFIELD_TYPE_TO_TYPE = Object.freeze({
-  single_line_text_field: String,
-  multi_line_text_field: String,
-  url_reference: String,
-  date: String,
-  date_time: String,
-  number_integer: 'number',
-  number_decimal: 'number',
-  product_reference: 'product',
-  collection_reference: 'collection',
-  variant_reference: 'variant',
-  page_reference: 'page',
-  boolean: 'boolean',
-  color: 'color',
-  weight: 'measurement',
-  volume: 'measurement',
-  dimension: 'measurement',
-  rating: 'rating',
-  money: 'money',
-  json: Untyped,
-  metaobject_reference: 'metaobject',
-  mixed_reference: Untyped,
-  rich_text_field: Untyped,
-  file_reference: Untyped,
-});
-
-const REFERENCE_TYPE_METAFIELDS = Object.entries(METAFIELD_TYPE_TO_TYPE)
-  .filter(([metafieldType, _type]) => metafieldType.endsWith('_reference'))
-  .map(([_metafieldType, type]) => type);
-
-function metafieldReturnType(metafieldType: string): ObjectEntry['return_type'] {
-  let isArray = metafieldType.startsWith('list.');
-
-  if (isArray) {
-    metafieldType = metafieldType.split('.')[1];
-  }
-
-  let type = 'metafield_' + ((METAFIELD_TYPE_TO_TYPE as any)[metafieldType] ?? Untyped);
-
-  if (isArray) {
-    return [{ type: `${type}_array`, name: '' }];
-  }
-
-  return [{ type: type, name: '' }];
-}
-
-// The default `metafield` type has an untyped `value` property.
-// We need to create new metafield types with the labels `metafield_x` and `metafield_x_array`
-// where x is the type of metafield inside the `value` property. The metafields ending with `x_array`
-// is where the value is an array of type x.
-const customMetafieldTypeEntries = memo((baseMetafieldEntry: ObjectEntry) => {
-  if (!baseMetafieldEntry) return {} as ObjectMap;
-
-  return [
-    ...new Set([...Object.values(METAFIELD_TYPE_TO_TYPE), ...FETCHED_METAFIELD_CATEGORIES]),
-  ].reduce((map, type) => {
-    {
-      const metafieldEntry = JSON.parse(JSON.stringify(baseMetafieldEntry)); // easy deep clone
-      const metafieldValueProp = metafieldEntry.properties?.find(
-        (prop: any) => prop.name === 'value',
-      );
-
-      if (metafieldValueProp) {
-        metafieldValueProp.return_type = [{ type: type, name: '' }];
-        metafieldValueProp.description = '';
-        metafieldEntry.name = `metafield_${type}`;
-        map[metafieldEntry.name] = metafieldEntry;
-      }
-    }
-
-    {
-      const metafieldArrayEntry = JSON.parse(JSON.stringify(baseMetafieldEntry)); // easy deep clone
-      const metafieldArrayValueProp = metafieldArrayEntry.properties?.find(
-        (prop: any) => prop.name === 'value',
-      );
-
-      if (metafieldArrayValueProp) {
-        // A metafield definition using a list of references does not use an array, but a separate type of collection.
-        // For auto-completion purposes, we can't use the array type
-        // https://shopify.dev/docs/api/liquid/objects/metafield#metafield-determining-the-length-of-a-list-metafield
-        if (REFERENCE_TYPE_METAFIELDS.includes(type as any)) {
-          metafieldArrayValueProp.return_type = [{ type: 'untyped', name: '' }];
-        } else {
-          metafieldArrayValueProp.return_type = [{ type: 'array', name: '', array_value: type }];
-        }
-        metafieldArrayValueProp.description = '';
-        metafieldArrayEntry.name = `metafield_${type}_array`;
-        map[metafieldArrayEntry.name] = metafieldArrayEntry;
-      }
-    }
-
-    return map;
-  }, {} as ObjectMap);
-});
-
-function schemaSettingsAsProperties(ast: LiquidHtmlNode): ObjectEntry[] {
-  if (ast.type !== NodeTypes.Document) return [];
-  try {
-    const source = ast._source; // (the unfixed source)
-    const start = /\{%\s*schema\s*%\}/m.exec(source);
-    const end = /\{%\s*endschema\s*%\}/m.exec(source);
-    if (!start || !end) return [];
-    const schema = source.slice(start.index + start[0].length, end.index);
-    const json = parseJSON(schema);
-    if (isError(json) || !('settings' in json) || !Array.isArray(json.settings)) return [];
-    const result: ObjectEntry[] = [];
-    const inputSettings = json.settings.filter(isInputSetting);
-    for (const setting of inputSettings) {
-      result.push({
-        name: setting.id,
-        summary: '', // TODO, this should lookup the locale file for settings... setting.label
-        description: '', // TODO , this should lookup the locale file as well... setting.info,
-        return_type: settingReturnType(setting),
-        access: {
-          global: false,
-          parents: [],
-          template: [],
-        },
-      });
-    }
-    return result;
-  } catch (_) {
-    return [];
-  }
-}