@platformos/platformos-check-common 0.0.2

package/src/checks/duplicate-content-for-arguments/index.ts

@@ -0,0 +1,43 @@
+import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
+import { ContentForMarkup, LiquidNamedArgument } from '@platformos/liquid-html-parser';
+import { getBlockName, reportDuplicateArguments } from '../../liquid-doc/arguments';
+
+export const DuplicateContentForArguments: LiquidCheckDefinition = {
+  meta: {
+    code: 'DuplicateContentForArguments',
+    name: 'Duplicate ContentFor Arguments',
+    docs: {
+      description:
+        'This check ensures that no duplicate argument names are provided when rendering a static block.',
+      recommended: true,
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/duplicate-content-for-arguments',
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.WARNING,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    return {
+      async ContentForMarkup(node: ContentForMarkup) {
+        const blockName = getBlockName(node);
+
+        if (!blockName) return;
+
+        const encounteredArgNames = new Set<string>();
+        const duplicateArgs: LiquidNamedArgument[] = [];
+
+        for (const param of node.args) {
+          if (encounteredArgNames.has(param.name)) {
+            duplicateArgs.push(param);
+          }
+
+          encounteredArgNames.add(param.name);
+        }
+
+        reportDuplicateArguments(context, node, duplicateArgs, blockName);
+      },
+    };
+  },
+};

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

@@ -0,0 +1,98 @@
+import { describe, it, expect } from 'vitest';
+import { DuplicateFunctionArguments } from '.';
+import { runLiquidCheck, applySuggestions } from '../../test';
+
+describe('Module: DuplicateFunctionArguments', () => {
+  function runCheck(sourceCode: string) {
+    return runLiquidCheck(DuplicateFunctionArguments, sourceCode);
+  }
+
+  describe('detection', () => {
+    it('should report duplicate arguments in function tags', async () => {
+      const sourceCode = `
+        {% function res = 'partial', param1: 'value1', param2: 'value2', param1: 'value3' %}
+      `;
+
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toMatch(/Duplicate argument 'param1'/);
+      expect(offenses[0].suggest).toBeDefined();
+      expect(offenses[0].suggest!.length).toBe(1);
+      expect(offenses[0].suggest![0].message).toBe("Remove duplicate argument 'param1'");
+    });
+
+    it('should report multiple duplicate arguments in function tags', async () => {
+      const sourceCode = `
+        {% function res = 'partial', param1: 'value1', param2: 'value2', param1: 'value3', param2: 'value4', param1: 'value5' %}
+      `;
+
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(3);
+      expect(offenses[0].message).toMatch(/Duplicate argument 'param1'/);
+      expect(offenses[0].start.index).toBe(sourceCode.indexOf("param1: 'value3'"));
+      expect(offenses[1].message).toMatch(/Duplicate argument 'param2'/);
+      expect(offenses[1].start.index).toBe(sourceCode.indexOf("param2: 'value4'"));
+      expect(offenses[2].message).toMatch(/Duplicate argument 'param1'/);
+      expect(offenses[2].start.index).toBe(sourceCode.indexOf("param1: 'value5'"));
+    });
+  });
+
+  describe('suggestions', () => {
+    it('should correctly suggest fixing all duplicate arguments except for the first', async () => {
+      const sourceCode = `{% function res = 'partial', param1: 'value1', param2: 'value2', param1: 'value3', param1: 'value4' %}`;
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(2);
+      expect(offenses[0].start.index).toBe(sourceCode.indexOf("param1: 'value3'"));
+      expect(offenses[1].start.index).toBe(sourceCode.indexOf("param1: 'value4'"));
+      const suggestionResult = applySuggestions(sourceCode, offenses[0]);
+      expect(suggestionResult).toEqual([
+        `{% function res = 'partial', param1: 'value1', param2: 'value2', param1: 'value4' %}`,
+      ]);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should not report when there are no duplicate arguments', async () => {
+      const sourceCode = `
+        {% function res = 'partial', param1: 'value1', param2: 'value2', param3: 'value3' %}
+      `;
+
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should not report for variable function tags where partial name is a variable', async () => {
+      const sourceCode = `
+        {% function res = variable, param1: 'value1', param1: 'value2' %}
+      `;
+
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should handle remove duplicate param when there are multiple function tags', async () => {
+      const sourceCode = `
+        {% function res = 'partial', param1: 'value1', param2: 'value2', param3: 'value3' %}
+        {% function res = 'partial', param1: 'value4', param2: 'value5', param1: 'value6' %}
+       `;
+
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toMatch(/Duplicate argument 'param1'/);
+      expect(offenses[0].start.index).toBe(sourceCode.indexOf("param1: 'value6'"));
+      const suggestionResult = applySuggestions(sourceCode, offenses[0]);
+      expect(suggestionResult).toEqual([
+        `
+        {% function res = 'partial', param1: 'value1', param2: 'value2', param3: 'value3' %}
+        {% function res = 'partial', param1: 'value4', param2: 'value5' %}
+       `,
+      ]);
+    });
+  });
+});

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

@@ -0,0 +1,44 @@
+import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
+import { LiquidNamedArgument, FunctionMarkup } from '@platformos/liquid-html-parser';
+import { getPartialName, reportDuplicateArguments } from '../../liquid-doc/arguments';
+
+export const DuplicateFunctionArguments: LiquidCheckDefinition = {
+  meta: {
+    code: 'DuplicateFunctionArguments',
+    name: 'Duplicate Function Arguments',
+    aliases: [],
+    docs: {
+      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',
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.WARNING,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    return {
+      async FunctionMarkup(node: FunctionMarkup) {
+        const partialName = getPartialName(node);
+
+        if (!partialName) return;
+
+        const encounteredArgNames = new Set<string>();
+        const duplicateArgs: LiquidNamedArgument[] = [];
+
+        for (const param of node.args) {
+          if (encounteredArgNames.has(param.name)) {
+            duplicateArgs.push(param);
+          }
+
+          encounteredArgNames.add(param.name);
+        }
+
+        reportDuplicateArguments(context, node, duplicateArgs, partialName);
+      },
+    };
+  },
+};

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

@@ -0,0 +1,120 @@
+import { describe, it, expect } from 'vitest';
+import { DuplicateRenderPartialArguments } from '.';
+import { runLiquidCheck, applySuggestions } from '../../test';
+
+describe('Module: DuplicateRenderPartialArguments', () => {
+  function runCheck(sourceCode: string) {
+    return runLiquidCheck(DuplicateRenderPartialArguments, sourceCode);
+  }
+
+  describe('detection', () => {
+    it('should report duplicate arguments in render tags', async () => {
+      const sourceCode = `
+        {% render 'snippet', param1: 'value1', param2: 'value2', param1: 'value3' %}
+      `;
+
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toMatch(/Duplicate argument 'param1'/);
+      expect(offenses[0].suggest).toBeDefined();
+      expect(offenses[0].suggest!.length).toBe(1);
+      expect(offenses[0].suggest![0].message).toBe("Remove duplicate argument 'param1'");
+    });
+
+    it('should report multiple duplicate arguments in render tags', async () => {
+      const sourceCode = `
+        {% render 'snippet', param1: 'value1', param2: 'value2', param1: 'value3', param2: 'value4', param1: 'value5' %}
+      `;
+
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(3);
+      expect(offenses[0].message).toMatch(/Duplicate argument 'param1'/);
+      expect(offenses[0].start.index).toBe(sourceCode.indexOf("param1: 'value3'"));
+      expect(offenses[1].message).toMatch(/Duplicate argument 'param2'/);
+      expect(offenses[1].start.index).toBe(sourceCode.indexOf("param2: 'value4'"));
+      expect(offenses[2].message).toMatch(/Duplicate argument 'param1'/);
+      expect(offenses[2].start.index).toBe(sourceCode.indexOf("param1: 'value5'"));
+    });
+
+    it('should not report when render tag is using `with/for` alias syntax', async () => {
+      const sourceCode = `
+        {% render 'snippet' with 'string' as param1, param1: 'value1' %}
+      `;
+
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toMatch(/Duplicate argument 'param1'/);
+    });
+  });
+
+  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 offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(2);
+      expect(offenses[0].start.index).toBe(sourceCode.indexOf("param1: 'value3'"));
+      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' %}`,
+      ]);
+    });
+
+    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 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' %}`,
+      ]);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should not report when there are no duplicate arguments', async () => {
+      const sourceCode = `
+        {% render 'snippet', param1: 'value1', param2: 'value2', param3: 'value3' %}
+      `;
+
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should not report for variable render tags where partial name is a variable', async () => {
+      const sourceCode = `
+        {% render my_variable, param1: 'value1', param1: 'value2' %}
+      `;
+
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(0);
+    });
+
+    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' %}
+       `;
+
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toMatch(/Duplicate argument 'param1'/);
+      expect(offenses[0].start.index).toBe(sourceCode.indexOf("param1: 'value6'"));
+      const suggestionResult = applySuggestions(sourceCode, offenses[0]);
+      expect(suggestionResult).toEqual([
+        `
+        {% render 'snippet', param1: 'value1', param2: 'value2', param3: 'value3' %}
+        {% render 'snippet', param1: 'value4', param2: 'value5' %}
+       `,
+      ]);
+    });
+  });
+});

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

@@ -0,0 +1,48 @@
+import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
+import { LiquidNamedArgument, RenderMarkup } from '@platformos/liquid-html-parser';
+import { getPartialName, reportDuplicateArguments } from '../../liquid-doc/arguments';
+
+export const DuplicateRenderPartialArguments: LiquidCheckDefinition = {
+  meta: {
+    code: 'DuplicateRenderPartialArguments',
+    name: 'Duplicate Render Partial Arguments',
+    aliases: ['DuplicateRenderPartialParams'],
+    docs: {
+      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',
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.WARNING,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    return {
+      async RenderMarkup(node: RenderMarkup) {
+        const partialName = getPartialName(node);
+
+        if (!partialName) return;
+
+        const encounteredArgNames = new Set<string>();
+        const duplicateArgs: LiquidNamedArgument[] = [];
+
+        if (node.alias?.value) {
+          encounteredArgNames.add(node.alias.value);
+        }
+
+        for (const param of node.args) {
+          if (encounteredArgNames.has(param.name)) {
+            duplicateArgs.push(param);
+          }
+
+          encounteredArgNames.add(param.name);
+        }
+
+        reportDuplicateArguments(context, node, duplicateArgs, partialName);
+      },
+    };
+  },
+};

package/src/checks/empty-block-content/index.spec.ts

@@ -0,0 +1,117 @@
+import { expect, describe, it } from 'vitest';
+import { EmptyBlockContent } from '.';
+import { check, MockTheme } from '../../test';
+
+describe('Module: EmptyBlockContent', () => {
+  const paths = ['sections', 'blocks'];
+
+  paths.forEach((path) => {
+    it(`should not report offenses when the blocks array is not empty in ${path}`, async () => {
+      const theme: MockTheme = {
+        [`${path}/test_block.liquid`]: `
+          <div> 
+              {% content_for 'blocks' %}
+          </div>
+          {% schema %}
+          {
+              "name": "Test",
+              "blocks": [
+                {
+                  "type": "test-block"
+                }
+              ]
+          }
+          {% endschema %}
+        `,
+      };
+
+      const offenses = await check(theme, [EmptyBlockContent]);
+      expect(offenses).to.have.length(0);
+    });
+
+    it(`should report offenses when the blocks array is empty in ${path}`, async () => {
+      const theme: MockTheme = {
+        [`${path}/test_block.liquid`]: `
+          <div> 
+              {% content_for 'blocks' %}
+          </div>
+          {% schema %}
+          {
+              "name": "Test",
+              "blocks": []
+          }
+          {% endschema %}
+        `,
+      };
+
+      const offenses = await check(theme, [EmptyBlockContent]);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal(
+        `The 'content_for "blocks"' tag is present, but the blocks array is empty.`,
+      );
+    });
+
+    it(`should report offenses when the blocks array is empty with the correct indices in ${path}`, async () => {
+      const theme: MockTheme = {
+        [`${path}/test_block.liquid`]: `
+          <div> 
+              {% content_for 'blocks' %}
+          </div>
+          {% schema %}
+          {
+              "name": "Test",
+              "blocks": []
+          }
+          {% endschema %}
+        `,
+      };
+
+      const offenses = await check(theme, [EmptyBlockContent]);
+      expect(offenses).to.have.length(1);
+      const content = theme[`${path}/test_block.liquid`];
+      const erroredContent = content.slice(offenses[0].start.index, offenses[0].end.index);
+      expect(erroredContent).to.equal("{% content_for 'blocks' %}");
+    });
+
+    it(`should report offenses when the blocks array has not been defined in ${path}`, async () => {
+      const theme: MockTheme = {
+        [`${path}/test_block.liquid`]: `
+          <div> 
+              {% content_for 'blocks' %}
+          </div>
+          {% schema %}
+          {
+              "name": "Test"
+          }
+          {% endschema %}
+        `,
+      };
+
+      const offenses = await check(theme, [EmptyBlockContent]);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal(
+        `The 'content_for "blocks"' tag is present, but the blocks array is not defined.`,
+      );
+    });
+
+    it(`should not report offenses when 'content_for blocks' is not present in ${path}`, async () => {
+      const theme: MockTheme = {
+        [`${path}/test_block.liquid`]: `
+          {% schema %}
+          {
+              "name": "Test",
+              "blocks": [
+                  {
+                      "type": "test-block"
+                  }
+              ]
+          }
+          {% endschema %}
+        `,
+      };
+
+      const offenses = await check(theme, [EmptyBlockContent]);
+      expect(offenses).to.be.empty;
+    });
+  });
+});

package/src/checks/empty-block-content/index.ts

@@ -0,0 +1,60 @@
+import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
+import { getSchema } from '../../to-schema';
+import { Position } from '@platformos/liquid-html-parser';
+
+export const EmptyBlockContent: LiquidCheckDefinition = {
+  meta: {
+    code: 'EmptyBlockContent',
+    name: 'Prevent empty block content',
+    docs: {
+      description:
+        'This check exists to warn you when the blocks array at the root level of the schema is empty.',
+      recommended: true,
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/empty-block-content',
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.WARNING,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    let isContentForBlocksLocationSet = false;
+    let contentForBlocksLocation: Position = { start: 0, end: 0 };
+
+    return {
+      async LiquidTag(node) {
+        if (node.name !== 'content_for') return;
+
+        const nodeMarkup = node.markup;
+        if (typeof nodeMarkup === 'object' && nodeMarkup.contentForType.value === 'blocks') {
+          contentForBlocksLocation.start = node.blockStartPosition.start;
+          contentForBlocksLocation.end = node.blockStartPosition.end;
+          isContentForBlocksLocationSet = true;
+        }
+      },
+
+      async onCodePathEnd() {
+        const schema = await getSchema(context);
+        const { validSchema, ast } = schema ?? {};
+        if (!validSchema || validSchema instanceof Error) return;
+        if (!ast || ast instanceof Error) return;
+
+        const blocks = validSchema.blocks;
+        if (isContentForBlocksLocationSet && !blocks) {
+          context.report({
+            message: `The 'content_for "blocks"' tag is present, but the blocks array is not defined.`,
+            startIndex: contentForBlocksLocation.start,
+            endIndex: contentForBlocksLocation.end,
+          });
+        } else if (isContentForBlocksLocationSet && blocks && blocks.length === 0) {
+          context.report({
+            message: `The 'content_for "blocks"' tag is present, but the blocks array is empty.`,
+            startIndex: contentForBlocksLocation.start,
+            endIndex: contentForBlocksLocation.end,
+          });
+        }
+      },
+    };
+  },
+};

package/src/checks/graphql/index.ts

@@ -0,0 +1,64 @@
+import { GraphQLCheckDefinition, Severity, SourceCodeType } from '../../types';
+import { parse } from 'graphql/language';
+import { buildSchema, validate } from 'graphql';
+
+function lineToRange(text: string, line: number): [number, number] {
+  const lines = text.split(/\r?\n/);
+
+  if (line < 1 || line > lines.length) {
+    return [0, text.length];
+  }
+
+  let start = 0;
+  for (let i = 0; i < line - 1; i++) {
+    start += lines[i].length + 1;
+  }
+
+  const end = start + lines[line - 1].length;
+  return [start, end];
+}
+
+export const GraphQLCheck: GraphQLCheckDefinition = {
+  meta: {
+    code: 'GraphQLCheck',
+    name: 'GraphQL Check',
+    docs: {
+      description: 'Ensures that GraphQL query or mutation is valid and matches predefined schema.',
+      recommended: true,
+      url: undefined,
+    },
+    type: SourceCodeType.GraphQL,
+    severity: Severity.ERROR,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    const validateContent = async (content: string) => {
+      const graphQLSchemaString = await context.themeDocset?.graphQL();
+      if (!graphQLSchemaString) {
+        return;
+      }
+
+      const graphQLSchema = buildSchema(graphQLSchemaString);
+
+      const document = parse(content);
+      const errors = validate(graphQLSchema, document);
+
+      errors.forEach((error) => {
+        const [start, end] = lineToRange(content, error.locations?.[0].line ?? 0);
+        context.report({
+          message: error.message,
+          startIndex: start,
+          endIndex: end,
+        });
+      });
+    };
+
+    return {
+      async onCodePathEnd(node) {
+        await validateContent(node.ast.content);
+      },
+    };
+  },
+};