@platformos/platformos-check-common 0.0.7 → 0.0.9

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

@@ -1,13 +1,5 @@
 import { LiquidFilter } from '@platformos/liquid-html-parser';
-import {
-  Severity,
-  SourceCodeType,
-  LiquidCheckDefinition,
-  LiquidHtmlSuggestion,
-  FilterEntry,
-  Fixer,
-} from '../../types';
-import { fixHexToRgba, suggestImageUrlFix, suggestImgTagFix, suggestImgUrlFix } from './fixes';
+import { Severity, SourceCodeType, LiquidCheckDefinition, FilterEntry } from '../../types';
 
 export const DeprecatedFilter: LiquidCheckDefinition = {
   meta: {
@@ -15,8 +7,8 @@ export const DeprecatedFilter: LiquidCheckDefinition = {
     aliases: ['DeprecatedFilters'],
     name: 'Deprecated Filter',
     docs: {
-      description: 'Discourages using deprecated filters in themes.',
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/deprecated-filter',
+      description: 'Discourages using deprecated filters.',
+      url: 'https://documentation.platformos.com/developer-guide/platformos-check/checks/deprecated-filter',
       recommended: true,
     },
     type: SourceCodeType.LiquidHtml,
@@ -26,13 +18,13 @@ export const DeprecatedFilter: LiquidCheckDefinition = {
   },
 
   create(context) {
-    if (!context.themeDocset) {
+    if (!context.platformosDocset) {
       return {};
     }
 
     return {
       LiquidFilter: async (node: LiquidFilter) => {
-        const filters = await context.themeDocset!.filters();
+        const filters = await context.platformosDocset!.filters();
 
         const deprecatedFilter = filters.find((f) => {
           return f.deprecated && f.name === node.name;
@@ -46,13 +38,9 @@ export const DeprecatedFilter: LiquidCheckDefinition = {
         const recommendedFilter = filters.find((f) => f.name === recommendedFilterName);
 
         const message = deprecatedFilterMessage(deprecatedFilter, recommendedFilter);
-        const suggest = deprecatedFilterSuggestion(node);
-        const fix = deprecatedFilterFix(node);
 
         context.report({
           message,
-          suggest,
-          fix,
           startIndex: node.position.start + 1,
           endIndex: node.position.end,
         });
@@ -61,42 +49,6 @@ export const DeprecatedFilter: LiquidCheckDefinition = {
   },
 };
 
-function deprecatedFilterSuggestion(node: LiquidFilter): LiquidHtmlSuggestion[] | undefined {
-  const filter = node.name;
-
-  switch (filter) {
-    case 'img_tag':
-      return suggestImgTagFix(node);
-    case 'img_url':
-      return suggestImgUrlFix(node);
-    case 'article_img_url':
-    case 'collection_img_url':
-    case 'product_img_url':
-      /**
-       * These filters rely on the usage of the `image_url`
-       * filter as the fix.
-       */
-      return suggestImageUrlFix(filter, node);
-    case 'currency_selector':
-      /**
-       * Cannot be fixed.
-       *
-       * Deprecated without a direct replacement because the
-       * currency form has also been deprecated. The currency
-       * form was replaced by the localization form.
-       */
-      return;
-  }
-}
-
-function deprecatedFilterFix(node: LiquidFilter): Fixer<SourceCodeType.LiquidHtml> | undefined {
-  const filter = node.name;
-
-  if (filter === 'hex_to_rgba') {
-    return fixHexToRgba(node);
-  }
-}
-
 function deprecatedFilterMessage(deprecated: FilterEntry, recommended?: FilterEntry) {
   if (recommended) {
     return `Deprecated filter '${deprecated.name}', consider using '${recommended.name}'.`;

package/src/checks/deprecated-tag/index.spec.ts

@@ -2,66 +2,117 @@ import { expect, describe, it } from 'vitest';
 import { highlightedOffenses, runLiquidCheck } from '../../test';
 import { DeprecatedTag } from './index';
 
-describe.skip('Module: DeprecatedTag', () => {
-  it('should report an offense when include tag is used', async () => {
-    const sourceCode = `
-      {% include 'templates/foo.liquid' %}
-    `;
-    const offenses = await runLiquidCheck(DeprecatedTag, sourceCode);
+const mockDependencies = {
+  platformosDocset: {
+    async graphQL() {
+      return null;
+    },
+    async filters() {
+      return [];
+    },
+    async objects() {
+      return [];
+    },
+    async liquidDrops() {
+      return [];
+    },
+    async tags() {
+      return [
+        {
+          name: 'include',
+          deprecated: true,
+          deprecation_reason: "Use the 'render' tag instead.",
+        },
+        {
+          name: 'deprecated_no_reason',
+          deprecated: true,
+        },
+        {
+          name: 'render',
+        },
+      ];
+    },
+  },
+};
+
+describe('Module: DeprecatedTag', () => {
+  it('should report an offense when a deprecated tag is used', async () => {
+    const sourceCode = `{% include 'templates/foo.liquid' %}`;
+
+    const offenses = await runLiquidCheck(
+      DeprecatedTag,
+      sourceCode,
+      'file.liquid',
+      mockDependencies,
+    );
 
     expect(offenses).toHaveLength(1);
-    expect(offenses[0].message).toEqual(`Use the 'render' tag instead of 'include'`);
+    expect(offenses[0].message).toEqual(`Deprecated tag 'include': Use the 'render' tag instead.`);
 
     const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
     expect(highlights).toEqual(['include']);
   });
 
-  it('should not report an offense when render tag is used', async () => {
-    const sourceCode = `
-      {% render 'templates/foo.liquid' %}
-    `;
-    const offenses = await runLiquidCheck(DeprecatedTag, sourceCode);
+  it('should not report an offense when a non-deprecated tag is used', async () => {
+    const sourceCode = `{% render 'templates/foo.liquid' %}`;
+
+    const offenses = await runLiquidCheck(
+      DeprecatedTag,
+      sourceCode,
+      'file.liquid',
+      mockDependencies,
+    );
 
     expect(offenses).toHaveLength(0);
+  });
 
-    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
-    expect(highlights).toHaveLength(0);
+  it('should report a generic message when no deprecation_reason is provided', async () => {
+    const sourceCode = `{% deprecated_no_reason %}`;
+
+    const offenses = await runLiquidCheck(
+      DeprecatedTag,
+      sourceCode,
+      'file.liquid',
+      mockDependencies,
+    );
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses[0].message).toEqual(`Deprecated tag 'deprecated_no_reason'.`);
   });
 
-  it('should suggest replacing include tag with render tag', async () => {
+  it('should report multiple offenses when multiple deprecated tags are used', async () => {
     const sourceCode = `
       {% include 'foo.liquid' %}
       {% assign greeting = "hello world" %}
       {% include 'greeting.liquid' %}
     `;
-    const offenses = await runLiquidCheck(DeprecatedTag, sourceCode);
 
-    expect(offenses).toHaveLength(2);
-    if (!offenses[0].suggest || !offenses[1].suggest) return;
+    const offenses = await runLiquidCheck(
+      DeprecatedTag,
+      sourceCode,
+      'file.liquid',
+      mockDependencies,
+    );
 
-    expect(offenses[0].suggest[0].message).toEqual(`Replace 'include' with 'render'`);
-    expect(offenses[1].suggest[0].message).toEqual(`Replace 'include' with 'render'`);
+    expect(offenses).toHaveLength(2);
+    expect(offenses[0].message).toEqual(`Deprecated tag 'include': Use the 'render' tag instead.`);
+    expect(offenses[1].message).toEqual(`Deprecated tag 'include': Use the 'render' tag instead.`);
 
     const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
-    expect(highlights).toHaveLength(2);
-    expect(highlights[0]).toBe('include');
-    expect(highlights[1]).toBe('include');
+    expect(highlights).toEqual(['include', 'include']);
   });
 
-  it('should report multiple offenses when multiple include tags are used in the same line', async () => {
-    const sourceCode = "{% include 'foo.liquid' %} Some text {% include 'bar.liquid' %}";
-    const offenses = await runLiquidCheck(DeprecatedTag, sourceCode);
+  it('should highlight only the tag name', async () => {
+    const sourceCode = `{% include 'foo.liquid' %}`;
 
-    expect(offenses).toHaveLength(2);
-  });
-
-  it('should report offenses when include tags are nested', async () => {
-    const sourceCode = "{% if true %} {% include 'foo.liquid' %} {% endif %}";
-    const offenses = await runLiquidCheck(DeprecatedTag, sourceCode);
+    const offenses = await runLiquidCheck(
+      DeprecatedTag,
+      sourceCode,
+      'file.liquid',
+      mockDependencies,
+    );
 
     expect(offenses).toHaveLength(1);
-    expect(offenses[0].message).toEqual(`Use the 'render' tag instead of 'include'`);
-
     const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
     expect(highlights).toEqual(['include']);
   });

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

@@ -7,7 +7,7 @@ export const DeprecatedTag: LiquidCheckDefinition = {
     name: 'Deprecated Tag',
     docs: {
       description: 'This check is aimed at eliminating the use of deprecated tags.',
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/deprecated-tag',
+      url: 'https://documentation.platformos.com/developer-guide/platformos-check/checks/deprecated-tag',
       recommended: true,
     },
     type: SourceCodeType.LiquidHtml,
@@ -17,29 +17,34 @@ export const DeprecatedTag: LiquidCheckDefinition = {
   },
 
   create(context) {
+    if (!context.platformosDocset) {
+      return {};
+    }
+
     return {
       async LiquidTag(node) {
-        // commenting this out to stop include from getting flagged
-        // if (node.name === 'include') {
-        //   const start = node.source.substring(node.position.start);
-        //   const includeStartIndex = start.indexOf('include');
-        //   const includeEndIndex = includeStartIndex + 'include'.length;
-        //   const includeStart = node.position.start + includeStartIndex;
-        //   const includeEnd = node.position.start + includeEndIndex;
-        //   context.report({
-        //     message: `Use the 'render' tag instead of 'include'`,
-        //     startIndex: includeStart,
-        //     endIndex: includeEnd,
-        //     suggest: [
-        //       {
-        //         message: `Replace 'include' with 'render'`,
-        //         fix: (corrector) => {
-        //           corrector.replace(includeStart, includeEnd, 'render');
-        //         },
-        //       },
-        //     ],
-        //   });
-        // }
+        const tags = await context.platformosDocset!.tags();
+
+        const deprecatedTag = tags.find((t) => t.deprecated && t.name === node.name);
+
+        if (!deprecatedTag) {
+          return;
+        }
+
+        const source = node.source.substring(node.position.start);
+        const tagNameIndex = source.indexOf(node.name);
+        const startIndex = node.position.start + tagNameIndex;
+        const endIndex = startIndex + node.name.length;
+
+        const message = deprecatedTag.deprecation_reason
+          ? `Deprecated tag '${node.name}': ${deprecatedTag.deprecation_reason}`
+          : `Deprecated tag '${node.name}'.`;
+
+        context.report({
+          message,
+          startIndex,
+          endIndex,
+        });
       },
     };
   },

package/src/checks/duplicate-function-arguments/index.ts

@@ -11,7 +11,7 @@ export const DuplicateFunctionArguments: LiquidCheckDefinition = {
       description:
         'This check ensures that no duplicate argument names are provided when invoking partial as a function.',
       recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/duplicate-function-arguments',
+      url: 'https://documentation.platformos.com/developer-guide/platformos-check/checks/duplicate-function-arguments',
     },
     type: SourceCodeType.LiquidHtml,
     severity: Severity.WARNING,

package/src/checks/duplicate-render-partial-arguments/index.spec.ts

@@ -10,7 +10,7 @@ describe('Module: DuplicateRenderPartialArguments', () => {
   describe('detection', () => {
     it('should report duplicate arguments in render tags', async () => {
       const sourceCode = `
-        {% render 'snippet', param1: 'value1', param2: 'value2', param1: 'value3' %}
+        {% render 'partial', param1: 'value1', param2: 'value2', param1: 'value3' %}
       `;
 
       const offenses = await runCheck(sourceCode);
@@ -24,7 +24,7 @@ describe('Module: DuplicateRenderPartialArguments', () => {
 
     it('should report multiple duplicate arguments in render tags', async () => {
       const sourceCode = `
-        {% render 'snippet', param1: 'value1', param2: 'value2', param1: 'value3', param2: 'value4', param1: 'value5' %}
+        {% render 'partial', param1: 'value1', param2: 'value2', param1: 'value3', param2: 'value4', param1: 'value5' %}
       `;
 
       const offenses = await runCheck(sourceCode);
@@ -40,7 +40,7 @@ describe('Module: DuplicateRenderPartialArguments', () => {
 
     it('should not report when render tag is using `with/for` alias syntax', async () => {
       const sourceCode = `
-        {% render 'snippet' with 'string' as param1, param1: 'value1' %}
+        {% render 'partial' with 'string' as param1, param1: 'value1' %}
       `;
 
       const offenses = await runCheck(sourceCode);
@@ -52,7 +52,7 @@ describe('Module: DuplicateRenderPartialArguments', () => {
 
   describe('suggestions', () => {
     it('should correctly suggest fixing all duplicate arguments except for the first', async () => {
-      const sourceCode = `{% render 'snippet', param1: 'value1', param2: 'value2', param1: 'value3', param1: 'value4' %}`;
+      const sourceCode = `{% render 'partial', param1: 'value1', param2: 'value2', param1: 'value3', param1: 'value4' %}`;
       const offenses = await runCheck(sourceCode);
 
       expect(offenses).toHaveLength(2);
@@ -60,18 +60,18 @@ describe('Module: DuplicateRenderPartialArguments', () => {
       expect(offenses[1].start.index).toBe(sourceCode.indexOf("param1: 'value4'"));
       const suggestionResult = applySuggestions(sourceCode, offenses[0]);
       expect(suggestionResult).toEqual([
-        `{% render 'snippet', param1: 'value1', param2: 'value2', param1: 'value4' %}`,
+        `{% render 'partial', param1: 'value1', param2: 'value2', param1: 'value4' %}`,
       ]);
     });
 
     it('should suggest removing duplicates when with / for alias is used', async () => {
-      const sourceCode = `{% render 'snippet' with 'string' as param2, param1: 'value1', param2: 'value2' %}`;
+      const sourceCode = `{% render 'partial' with 'string' as param2, param1: 'value1', param2: 'value2' %}`;
       const offenses = await runCheck(sourceCode);
 
       expect(offenses).toHaveLength(1);
       const suggestionResult = applySuggestions(sourceCode, offenses[0]);
       expect(suggestionResult).toEqual([
-        `{% render 'snippet' with 'string' as param2, param1: 'value1' %}`,
+        `{% render 'partial' with 'string' as param2, param1: 'value1' %}`,
       ]);
     });
   });
@@ -79,7 +79,7 @@ describe('Module: DuplicateRenderPartialArguments', () => {
   describe('edge cases', () => {
     it('should not report when there are no duplicate arguments', async () => {
       const sourceCode = `
-        {% render 'snippet', param1: 'value1', param2: 'value2', param3: 'value3' %}
+        {% render 'partial', param1: 'value1', param2: 'value2', param3: 'value3' %}
       `;
 
       const offenses = await runCheck(sourceCode);
@@ -99,8 +99,8 @@ describe('Module: DuplicateRenderPartialArguments', () => {
 
     it('should handle remove duplicate param when there are multiple render tags', async () => {
       const sourceCode = `
-        {% render 'snippet', param1: 'value1', param2: 'value2', param3: 'value3' %}
-        {% render 'snippet', param1: 'value4', param2: 'value5', param1: 'value6' %}
+        {% render 'partial', param1: 'value1', param2: 'value2', param3: 'value3' %}
+        {% render 'partial', param1: 'value4', param2: 'value5', param1: 'value6' %}
        `;
 
       const offenses = await runCheck(sourceCode);
@@ -111,8 +111,8 @@ describe('Module: DuplicateRenderPartialArguments', () => {
       const suggestionResult = applySuggestions(sourceCode, offenses[0]);
       expect(suggestionResult).toEqual([
         `
-        {% render 'snippet', param1: 'value1', param2: 'value2', param3: 'value3' %}
-        {% render 'snippet', param1: 'value4', param2: 'value5' %}
+        {% render 'partial', param1: 'value1', param2: 'value2', param3: 'value3' %}
+        {% render 'partial', param1: 'value4', param2: 'value5' %}
        `,
       ]);
     });

package/src/checks/duplicate-render-partial-arguments/index.ts

@@ -11,7 +11,7 @@ export const DuplicateRenderPartialArguments: LiquidCheckDefinition = {
       description:
         'This check ensures that no duplicate argument names are provided when rendering a partial.',
       recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/duplicate-render-partial-arguments',
+      url: 'https://documentation.platformos.com/developer-guide/platformos-check/checks/duplicate-render-partial-arguments',
     },
     type: SourceCodeType.LiquidHtml,
     severity: Severity.WARNING,

package/src/checks/graphql/index.ts

@@ -35,7 +35,7 @@ export const GraphQLCheck: GraphQLCheckDefinition = {
 
   create(context) {
     const validateContent = async (content: string) => {
-      const graphQLSchemaString = await context.themeDocset?.graphQL();
+      const graphQLSchemaString = await context.platformosDocset?.graphQL();
       if (!graphQLSchemaString) {
         return;
       }

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

@@ -0,0 +1,95 @@
+import { expect, describe, it } from 'vitest';
+import { GraphQLVariablesCheck } from '.';
+import { check } from '../../test';
+
+const GRAPHQL_WITH_REQUIRED = `
+  query MyQuery($content: String!) {
+    records(filter: { table: { value: "posts" } }) {
+      results {
+        id
+      }
+    }
+  }
+`;
+
+const GRAPHQL_WITH_OPTIONAL = `
+  query MyQuery($content: String) {
+    records(filter: { table: { value: "posts" } }) {
+      results {
+        id
+      }
+    }
+  }
+`;
+
+describe('Module: GraphQLVariablesCheck', () => {
+  it('reports a missing required parameter', async () => {
+    const files = {
+      'app/views/partials/page.liquid': `{% graphql r = 'create' %}`,
+      'app/graphql/create.graphql': GRAPHQL_WITH_REQUIRED,
+    };
+
+    const offenses = await check(files, [GraphQLVariablesCheck]);
+
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal(
+      'Required parameter content must be passed to GraphQL call',
+    );
+  });
+
+  it('does not report when all required parameters are provided', async () => {
+    const files = {
+      'app/views/partials/page.liquid': `{% graphql r = 'create', content: 'hello' %}`,
+      'app/graphql/create.graphql': GRAPHQL_WITH_REQUIRED,
+    };
+
+    const offenses = await check(files, [GraphQLVariablesCheck]);
+
+    expect(offenses).to.be.empty;
+  });
+
+  it('does not report when the parameter is optional', async () => {
+    const files = {
+      'app/views/partials/page.liquid': `{% graphql r = 'create' %}`,
+      'app/graphql/create.graphql': GRAPHQL_WITH_OPTIONAL,
+    };
+
+    const offenses = await check(files, [GraphQLVariablesCheck]);
+
+    expect(offenses).to.be.empty;
+  });
+
+  it('does not report when args is used (hash splat)', async () => {
+    const files = {
+      'app/views/partials/page.liquid': `{% graphql r = 'create', args: object %}`,
+      'app/graphql/create.graphql': GRAPHQL_WITH_REQUIRED,
+    };
+
+    const offenses = await check(files, [GraphQLVariablesCheck]);
+
+    expect(offenses).to.be.empty;
+  });
+
+  it('does not report unknown parameter when args is used', async () => {
+    const files = {
+      'app/views/partials/page.liquid': `{% graphql r = 'create', args: object, extra: 'x' %}`,
+      'app/graphql/create.graphql': GRAPHQL_WITH_REQUIRED,
+    };
+
+    const offenses = await check(files, [GraphQLVariablesCheck]);
+
+    expect(offenses).to.be.empty;
+  });
+
+  it('reports an unknown parameter when args is not used', async () => {
+    const files = {
+      'app/views/partials/page.liquid': `{% graphql r = 'create', content: 'hello', unknown: 'x' %}`,
+      'app/graphql/create.graphql': GRAPHQL_WITH_REQUIRED,
+    };
+
+    const offenses = await check(files, [GraphQLVariablesCheck]);
+
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal('Unknown parameter unknown passed to GraphQL call');
+  });
+});

package/src/checks/graphql-variables/index.ts

@@ -64,6 +64,10 @@ export const GraphQLVariablesCheck: LiquidCheckDefinition = {
       args: LiquidNamedArgument[],
       position: Position,
     ) => {
+      // `args` is a special parameter that splats a hash as all GraphQL variables
+      // at runtime — we can't know which keys will be provided statically.
+      if (args.some((arg) => arg.name === 'args')) return;
+
       const locatedFile = await locator.locate(
         URI.parse(context.config.rootUri),
         'graphql',

package/src/checks/img-width-and-height/index.ts

@@ -7,9 +7,9 @@ export const ImgWidthAndHeight: LiquidCheckDefinition = {
     name: 'Width and height attributes on image tags',
     docs: {
       description:
-        'This check is aimed at eliminating content layout shift in themes by enforcing the use of the width and height attributes on img tags.',
+        'This check is aimed at eliminating content layout shift by enforcing the use of the width and height attributes on img tags.',
       recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/img-width-and-height',
+      url: 'https://documentation.platformos.com/developer-guide/platformos-check/checks/img-width-and-height',
     },
     type: SourceCodeType.LiquidHtml,
     severity: Severity.ERROR,