@platformos/platformos-check-common 0.0.11 → 0.0.13

package/src/checks/deprecated-filter/index.ts

@@ -39,10 +39,27 @@ export const DeprecatedFilter: LiquidCheckDefinition = {
 
         const message = deprecatedFilterMessage(deprecatedFilter, recommendedFilter);
 
+        const filterText = node.source.slice(node.position.start, node.position.end);
+        const afterPipeIdx = filterText.indexOf('|') + 1;
+        const nameIdx =
+          afterPipeIdx + filterText.slice(afterPipeIdx).indexOf(deprecatedFilter.name);
+        const filterNameStart = node.position.start + nameIdx;
+        const filterNameEnd = filterNameStart + deprecatedFilter.name.length;
+
         context.report({
           message,
           startIndex: node.position.start + 1,
           endIndex: node.position.end,
+          suggest: recommendedFilter
+            ? [
+                {
+                  message: `Replace '${deprecatedFilter.name}' with '${recommendedFilter.name}'`,
+                  fix: (corrector) => {
+                    corrector.replace(filterNameStart, filterNameEnd, recommendedFilter.name);
+                  },
+                },
+              ]
+            : undefined,
         });
       },
     };

package/src/checks/graphql/index.spec.ts

@@ -0,0 +1,173 @@
+import { expect, describe, it } from 'vitest';
+import { GraphQLCheck, lineToRange } from './index';
+import { check } from '../../test';
+
+const SCHEMA = `
+  type Query {
+    hello: String
+    users: [User]
+  }
+
+  type User {
+    id: ID
+    name: String
+  }
+`;
+
+const mockDependencies = {
+  platformosDocset: {
+    async graphQL() {
+      return SCHEMA;
+    },
+    async filters() {
+      return [];
+    },
+    async objects() {
+      return [];
+    },
+    async liquidDrops() {
+      return [];
+    },
+    async tags() {
+      return [];
+    },
+  },
+};
+
+const noDeps = {
+  platformosDocset: {
+    async graphQL() {
+      return null;
+    },
+    async filters() {
+      return [];
+    },
+    async objects() {
+      return [];
+    },
+    async liquidDrops() {
+      return [];
+    },
+    async tags() {
+      return [];
+    },
+  },
+};
+
+describe('Module: GraphQLCheck', () => {
+  it('reports no offenses for a valid query', async () => {
+    const files = {
+      'app/graphql/my_query.graphql': '{ hello }',
+    };
+
+    const offenses = await check(files, [GraphQLCheck], mockDependencies);
+    expect(offenses).to.be.empty;
+  });
+
+  it('reports an offense for an unknown field', async () => {
+    const files = {
+      'app/graphql/my_query.graphql': '{ unknownField }',
+    };
+
+    const offenses = await check(files, [GraphQLCheck], mockDependencies);
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal('Cannot query field "unknownField" on type "Query".');
+  });
+
+  it('offense for unknown field spans only the affected line, not the entire file', async () => {
+    const query = `{
+  unknownField
+}`;
+    const files = {
+      'app/graphql/my_query.graphql': query,
+    };
+
+    const offenses = await check(files, [GraphQLCheck], mockDependencies);
+    expect(offenses).to.have.length(1);
+
+    // Should point to line 2 (1-based), which is "  unknownField"
+    // and NOT span to the end of the file
+    expect(offenses[0].start.line).to.equal(1); // 0-based: line index 1 = "  unknownField"
+    expect(offenses[0].end.line).to.equal(1);
+  });
+
+  it('reports a syntax error offense instead of swallowing it', async () => {
+    const files = {
+      'app/graphql/my_query.graphql': '{ unclosed {',
+    };
+
+    const offenses = await check(files, [GraphQLCheck], mockDependencies);
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal('Syntax Error: Expected Name, found <EOF>.');
+  });
+
+  it('syntax error offense points to the actual error line, not the whole file', async () => {
+    // unclosed brace on line 3 causes a parse error — graphql-js will report the exact location
+    const query = `{
+  hello
+  unclosed {
+`;
+    const files = {
+      'app/graphql/my_query.graphql': query,
+    };
+
+    const offenses = await check(files, [GraphQLCheck], mockDependencies);
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal('Syntax Error: Expected Name, found <EOF>.');
+    // Offense spans exactly one line (the error line), NOT the whole file
+    expect(offenses[0].start.line).to.equal(offenses[0].end.line);
+    // And that line is not the last line of the file (i.e. not spanning to the end)
+    expect(offenses[0].end.line).to.be.lessThan(3); // file has 4 lines (0-indexed: 0-3)
+  });
+
+  it('reports no offenses when platformosDocset.graphQL returns null', async () => {
+    const files = {
+      'app/graphql/my_query.graphql': '{ unknownField }',
+    };
+
+    const offenses = await check(files, [GraphQLCheck], noDeps);
+    expect(offenses).to.be.empty;
+  });
+});
+
+describe('Unit: lineToRange', () => {
+  const TEXT = 'line1\nline2\nline3';
+
+  it('returns correct range for line 1', () => {
+    expect(lineToRange(TEXT, 1)).to.eql([0, 5]); // "line1"
+  });
+
+  it('returns correct range for line 2', () => {
+    expect(lineToRange(TEXT, 2)).to.eql([6, 11]); // "line2"
+  });
+
+  it('returns correct range for line 3', () => {
+    expect(lineToRange(TEXT, 3)).to.eql([12, 17]); // "line3"
+  });
+
+  it('clamps line 0 to first line instead of spanning the whole file', () => {
+    const [start, end] = lineToRange(TEXT, 0);
+    expect(start).to.equal(0);
+    expect(end).to.equal(5); // "line1" length = 5, not TEXT.length (17)
+  });
+
+  it('clamps line beyond last to last line instead of spanning the whole file', () => {
+    const [start, end] = lineToRange(TEXT, 999);
+    expect(start).to.equal(12);
+    expect(end).to.equal(17); // "line3"
+  });
+
+  it('handles single-line text with line 0', () => {
+    const [start, end] = lineToRange('hello', 0);
+    expect(start).to.equal(0);
+    expect(end).to.equal(5); // entire single line, NOT text.length (which happens to be the same here)
+  });
+
+  it('does not return the whole file when line is 0', () => {
+    const longText = 'first line\nsecond line\nthird line';
+    const [, end] = lineToRange(longText, 0);
+    // Should be end of first line (10), not end of whole text (33)
+    expect(end).to.equal(10);
+    expect(end).to.not.equal(longText.length);
+  });
+});

package/src/checks/graphql/index.ts

@@ -1,20 +1,17 @@
 import { GraphQLCheckDefinition, Severity, SourceCodeType } from '../../types';
 import { parse } from 'graphql/language';
-import { buildSchema, validate } from 'graphql';
+import { buildSchema, GraphQLError, validate } from 'graphql';
 
-function lineToRange(text: string, line: number): [number, number] {
+export function lineToRange(text: string, line: number): [number, number] {
   const lines = text.split(/\r?\n/);
-
-  if (line < 1 || line > lines.length) {
-    return [0, text.length];
-  }
+  const clampedLine = Math.max(1, Math.min(line, lines.length));
 
   let start = 0;
-  for (let i = 0; i < line - 1; i++) {
+  for (let i = 0; i < clampedLine - 1; i++) {
     start += lines[i].length + 1;
   }
 
-  const end = start + lines[line - 1].length;
+  const end = start + lines[clampedLine - 1].length;
   return [start, end];
 }
 
@@ -42,11 +39,25 @@ export const GraphQLCheck: GraphQLCheckDefinition = {
 
       const graphQLSchema = buildSchema(graphQLSchemaString);
 
-      const document = parse(content);
+      let document;
+      try {
+        document = parse(content);
+      } catch (e) {
+        if (e instanceof GraphQLError) {
+          const [start, end] = lineToRange(content, e.locations?.[0]?.line ?? 1);
+          context.report({
+            message: e.message,
+            startIndex: start,
+            endIndex: end,
+          });
+        }
+        return;
+      }
+
       const errors = validate(graphQLSchema, document);
 
       errors.forEach((error) => {
-        const [start, end] = lineToRange(content, error.locations?.[0].line ?? 0);
+        const [start, end] = lineToRange(content, error.locations?.[0]?.line ?? 0);
         context.report({
           message: error.message,
           startIndex: start,

package/src/checks/index.ts

@@ -36,6 +36,9 @@ import { GraphQLCheck } from './graphql';
 import { UnknownProperty } from './unknown-property';
 import { InvalidHashAssignTarget } from './invalid-hash-assign-target';
 import { DuplicateFunctionArguments } from './duplicate-function-arguments';
+import { MissingRenderPartialArguments } from './missing-render-partial-arguments';
+import { NestedGraphQLQuery } from './nested-graphql-query';
+import { MissingPage } from './missing-page';
 
 export const allChecks: (
   | LiquidCheckDefinition
@@ -73,6 +76,9 @@ export const allChecks: (
   GraphQLCheck,
   UnknownProperty,
   InvalidHashAssignTarget,
+  MissingRenderPartialArguments,
+  NestedGraphQLQuery,
+  MissingPage,
 ];
 
 /**

package/src/checks/invalid-hash-assign-target/index.spec.ts

@@ -119,6 +119,32 @@ describe('Module: InvalidHashAssignTarget', () => {
     expect(offenses).toHaveLength(0);
   });
 
+  it('should not report an error when hash_assign is used on a function return with variable partial', async () => {
+    const app: MockApp = {
+      'file.liquid': `
+        {% assign partial_name = 'lib/get_data' %}
+        {% function data = partial_name %}
+        {% hash_assign data['extra'] = 'value' %}
+      `,
+    };
+
+    const offenses = await check(app, [InvalidHashAssignTarget]);
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should not report an error when function uses hash-access result target and hash_assign follows', async () => {
+    const app: MockApp = {
+      'file.liquid': `
+        {% parse_json my_hash %}{}{% endparse_json %}
+        {% function my_hash['result'] = 'lib/get_data' %}
+        {% hash_assign my_hash['extra'] = 'value' %}
+      `,
+    };
+
+    const offenses = await check(app, [InvalidHashAssignTarget]);
+    expect(offenses).toHaveLength(0);
+  });
+
   it('should track reassignment and report error on new type', async () => {
     const app: MockApp = {
       'file.liquid': `

package/src/checks/invalid-hash-assign-target/index.ts

@@ -7,6 +7,7 @@ import {
   HashAssignMarkup,
   GraphQLMarkup,
   GraphQLInlineMarkup,
+  FunctionMarkup,
 } from '@platformos/liquid-html-parser';
 import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
 import { isError } from '../../utils';
@@ -229,12 +230,13 @@ export const InvalidHashAssignTarget: LiquidCheckDefinition = {
 
         // {% function result = 'path' %}
         if (node.name === NamedTags.function && typeof node.markup !== 'string') {
-          const markup = node.markup as { name: string };
-          if (markup.name) {
-            closeTypeRange(markup.name, node.position.start);
+          const markup = node.markup as FunctionMarkup;
+          const varName = markup.name.name;
+          if (varName) {
+            closeTypeRange(varName, node.position.start);
             // Function returns are untyped unless we can infer them
             variableTypes.push({
-              name: markup.name,
+              name: varName,
               type: 'untyped',
               range: [node.position.end],
             });