@platformos/platformos-check-common 0.0.2

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

@@ -0,0 +1,98 @@
+import { ContentForMarkup, NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
+import {
+  CLOSEST_ARGUMENT,
+  REQUIRED_CONTENT_FOR_ARGUMENTS,
+  RESERVED_CONTENT_FOR_ARGUMENTS,
+} from '../../tags/content-for';
+
+export const ValidContentForArguments: LiquidCheckDefinition = {
+  meta: {
+    code: 'ValidContentForArguments',
+    name: 'Prevent the use of invalid arguments to the content_for tag',
+    docs: {
+      description:
+        'This check is aimed at preventing the use of invalid arguments for the content_for tag.',
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/valid-content-for-arguments',
+      recommended: true,
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.ERROR,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    const validationStrategies = {
+      blocks: (node: ContentForMarkup) => {
+        const problematicArguments = node.args.filter(
+          (arg) => !arg.name.startsWith(CLOSEST_ARGUMENT),
+        );
+
+        for (const arg of problematicArguments) {
+          context.report({
+            message: `{% content_for "blocks" %} only accepts 'closest.*' arguments`,
+            startIndex: arg.position.start,
+            endIndex: arg.position.end,
+          });
+        }
+      },
+
+      block: (node: ContentForMarkup) => {
+        // Make sure the id and string arguments are present and are strings
+        for (const requiredArgumentName of REQUIRED_CONTENT_FOR_ARGUMENTS) {
+          const arg = node.args.find((arg) => arg.name === requiredArgumentName);
+
+          if (!arg) {
+            context.report({
+              message: `{% content_for "block" %} requires a '${requiredArgumentName}' argument`,
+              startIndex: node.position.start,
+              endIndex: node.position.end,
+              suggest: [],
+            });
+            continue;
+          }
+
+          const argValueNode = arg.value;
+          if (argValueNode.type !== NodeTypes.String) {
+            context.report({
+              message: `The '${requiredArgumentName}' argument should be a string`,
+              startIndex: argValueNode.position.start,
+              endIndex: argValueNode.position.end,
+              suggest: [],
+            });
+          }
+        }
+
+        const problematicArguments = node.args.filter((arg) =>
+          RESERVED_CONTENT_FOR_ARGUMENTS.includes(arg.name),
+        );
+
+        for (const arg of problematicArguments) {
+          context.report({
+            message: `{% content_for "block" %} doesn't support '${arg.name}' because it's a reserved argument.`,
+            startIndex: arg.position.start,
+            endIndex: arg.position.end,
+          });
+        }
+      },
+    };
+
+    return {
+      async LiquidTag(node) {
+        if (node.name !== 'content_for' || typeof node.markup === 'string') {
+          return;
+        }
+
+        /** "block", "blocks", etc. */
+        const contentForType = node.markup.contentForType.value;
+        const validate = validationStrategies[contentForType as keyof typeof validationStrategies];
+        if (!validate) {
+          return;
+        }
+
+        validate(node.markup);
+      },
+    };
+  },
+};

package/src/checks/valid-doc-param-types/index.spec.ts

@@ -0,0 +1,75 @@
+import { expect, describe, it } from 'vitest';
+import { ValidDocParamTypes } from './index';
+import { runLiquidCheck, applySuggestions } from '../../test';
+import { BasicParamTypes } from '../../liquid-doc/utils';
+
+describe('Module: ValidDocParamTypes', () => {
+  Object.values(BasicParamTypes).forEach((paramType) => {
+    it(`should not report an error when a valid basic parameter (${paramType}) type is used`, async () => {
+      const sourceCode = `
+        {% doc %}
+          @param {${paramType}} param1 - Example param
+        {% enddoc %}
+      `;
+
+      const offenses = await runLiquidCheck(ValidDocParamTypes, sourceCode);
+
+      expect(offenses).to.be.empty;
+    });
+  });
+
+  it(`should not report an error when a valid liquid object parameter (product) type is used`, async () => {
+    const sourceCode = `
+      {% doc %}
+        @param {product} param1 - Example param
+      {% enddoc %}
+    `;
+
+    const offenses = await runLiquidCheck(ValidDocParamTypes, sourceCode);
+
+    expect(offenses).to.be.empty;
+  });
+
+  it(`should not report an error when a valid liquid object array parameter (product[]) type is used`, async () => {
+    const sourceCode = `
+      {% doc %}
+        @param {product[]} param1 - Example param
+      {% enddoc %}
+    `;
+
+    const offenses = await runLiquidCheck(ValidDocParamTypes, sourceCode);
+
+    expect(offenses).to.be.empty;
+  });
+
+  it('should report an error with suggestions when an invalid parameter type is used', async () => {
+    const sourceCode = `
+      {% doc %}
+        @param {invalidType} param1 - Example param
+      {% enddoc %}
+    `;
+
+    const offenses = await runLiquidCheck(ValidDocParamTypes, sourceCode);
+
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal("The parameter type 'invalidType' is not supported.");
+    expect(offenses[0].suggest).to.have.length(1);
+    expect(offenses[0]!.suggest![0].message).to.equal('Remove invalid parameter type');
+  });
+
+  it('should apply suggestion when an invalid parameter type is used', async () => {
+    const sources = [
+      `{% doc %} @param {invalidType} param1 - Example param {% enddoc %}`,
+      `{% doc %} @param   {   invalidType   }   param1 - Example param {% enddoc %}`,
+    ];
+
+    for (const source of sources) {
+      const offenses = await runLiquidCheck(ValidDocParamTypes, source);
+
+      expect(offenses).to.have.length(1);
+      const suggestions = applySuggestions(source, offenses[0]);
+
+      expect(suggestions).to.include(`{% doc %} @param param1 - Example param {% enddoc %}`);
+    }
+  });
+});

package/src/checks/valid-doc-param-types/index.ts

@@ -0,0 +1,71 @@
+import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
+import { getValidParamTypes, parseParamType } from '../../liquid-doc/utils';
+
+export const ValidDocParamTypes: LiquidCheckDefinition = {
+  meta: {
+    code: 'ValidDocParamTypes',
+    name: 'Valid doc parameter types',
+    docs: {
+      description:
+        'This check exists to ensure any parameter types defined in the `doc` tag are valid.',
+      recommended: true,
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/valid-doc-param-types',
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.ERROR,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    if (!context.themeDocset) {
+      return {};
+    }
+
+    // To avoid recalculating valid param types during theme-check, constructing
+    // the promise beforehand.
+    const validParamTypesPromise = context
+      .themeDocset!.liquidDrops()
+      .then((entries) => new Set(getValidParamTypes(entries).keys()));
+
+    return {
+      async LiquidDocParamNode(node) {
+        if (!node.paramType) {
+          return;
+        }
+
+        const parsedParamType = parseParamType(await validParamTypesPromise, node.paramType.value);
+
+        if (parsedParamType) {
+          return;
+        }
+
+        context.report({
+          message: `The parameter type '${node.paramType.value}' is not supported.`,
+          // Index is offset to include the curly brackets around the param type
+          startIndex: node.paramType.position.start - 1,
+          endIndex: node.paramType.position.end + 1,
+          suggest: [
+            {
+              message: 'Remove invalid parameter type',
+              fix: (corrector) => {
+                if (!node.paramType) return;
+
+                corrector.replace(
+                  node.position.start,
+                  node.position.end,
+                  node.source.slice(node.position.start, node.position.end).replace(
+                    // We could have padded spaces around + inside the param type
+                    // e.g. `{ string }`, `{string}`, or ` { string } `
+                    /\s*\{\s*[^\s]+\s*\}\s*/,
+                    ' ',
+                  ),
+                );
+              },
+            },
+          ],
+        });
+      },
+    };
+  },
+};

package/src/checks/valid-html-translation/index.spec.ts

@@ -0,0 +1,74 @@
+import { ValidHTMLTranslation } from './index';
+import { highlightedOffenses, runJSONCheck } from '../../test';
+import { expect, describe, it } from 'vitest';
+
+describe('Module: ValidHTMLTranslation', () => {
+  it('should not report valid HTML in translations', async () => {
+    const sourceCode = JSON.stringify({
+      hello_html: '<h1>Hello, world</h1>',
+      image_html: "<img src='spongebob.png'>",
+      line_break_html: '<br>',
+      self_closing_svg_html: '<svg />',
+      foo: 'bar',
+    });
+
+    const offenses = await runJSONCheck(ValidHTMLTranslation, sourceCode, 'locales/en.json');
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should report invalid HTML in translations', async () => {
+    const sourceCode = JSON.stringify({
+      hello_html: '<h1>Hello, world',
+    });
+
+    const offenses = await runJSONCheck(ValidHTMLTranslation, sourceCode, 'locales/en.json');
+    expect(offenses).toHaveLength(1);
+    expect(offenses[0].message).to.equal(
+      "LiquidHTMLParsingError: Attempting to end parsing before HtmlElement 'h1' was closed.",
+    );
+
+    const highlights = highlightedOffenses({ 'locales/en.json': sourceCode }, offenses);
+    expect(highlights).toHaveLength(1);
+    expect(highlights[0]).to.equal(`"<h1>Hello, world"`);
+  });
+
+  it('should report nested invalid HTML in translations', async () => {
+    const sourceCode = JSON.stringify({
+      hello: {
+        world: {
+          today: {
+            good: {
+              day_html: '<h1>Hello, world',
+            },
+          },
+        },
+      },
+    });
+
+    const offenses = await runJSONCheck(ValidHTMLTranslation, sourceCode, 'locales/en.json');
+    expect(offenses).toHaveLength(1);
+    expect(offenses[0].message).to.equal(
+      "LiquidHTMLParsingError: Attempting to end parsing before HtmlElement 'h1' was closed.",
+    );
+
+    const highlights = highlightedOffenses({ 'locales/en.json': sourceCode }, offenses);
+    expect(highlights).toHaveLength(1);
+    expect(highlights[0]).to.equal(`"<h1>Hello, world"`);
+  });
+
+  it('should report pluralized key with invalid HTML', async () => {
+    const sourceCode = JSON.stringify({
+      hello_html: { one: '<h1>Hello, world' },
+    });
+
+    const offenses = await runJSONCheck(ValidHTMLTranslation, sourceCode, 'locales/en.json');
+    expect(offenses).toHaveLength(1);
+    expect(offenses[0].message).to.equal(
+      "LiquidHTMLParsingError: Attempting to end parsing before HtmlElement 'h1' was closed.",
+    );
+
+    const highlights = highlightedOffenses({ 'locales/en.json': sourceCode }, offenses);
+    expect(highlights).toHaveLength(1);
+    expect(highlights[0]).to.equal(`"<h1>Hello, world"`);
+  });
+});

package/src/checks/valid-html-translation/index.ts

@@ -0,0 +1,45 @@
+import { SourceCodeType, JSONCheckDefinition, Severity, Problem, LiteralNode } from '../../types';
+import { toLiquidHtmlAST } from '@platformos/liquid-html-parser';
+
+export const ValidHTMLTranslation: JSONCheckDefinition = {
+  meta: {
+    code: 'ValidHTMLTranslation',
+    name: 'Valid HTML Translation',
+    docs: {
+      description: 'This check exists to prevent invalid HTML inside translations.',
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/valid-html-translation',
+      recommended: true,
+    },
+    type: SourceCodeType.JSON,
+    severity: Severity.WARNING,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    // We ignore non-`locales/` json files.
+    const relativePath = context.toRelativePath(context.file.uri);
+    if (!relativePath.startsWith('locales/')) return {};
+
+    return {
+      async Literal(node: LiteralNode) {
+        const htmlRegex = /<[^>]+>/;
+
+        if (typeof node.value !== 'string' || !htmlRegex.test(node.value)) return;
+
+        try {
+          toLiquidHtmlAST(node.value);
+        } catch (error) {
+          const loc = node.loc;
+
+          const problem: Problem<SourceCodeType.JSON> = {
+            message: `${error}.`,
+            startIndex: loc.start.offset,
+            endIndex: loc.end.offset,
+          };
+          context.report(problem);
+        }
+      },
+    };
+  },
+};

package/src/checks/valid-json/index.spec.ts

@@ -0,0 +1,102 @@
+import { expect, describe, it } from 'vitest';
+import { ValidJSON } from './index';
+import { highlightedOffenses, runJSONCheck } from '../../test';
+
+describe('Module: ValidJSON', () => {
+  it('should report an error for invalid JSON (0)', async () => {
+    const invalidJson = `{
+      "key1": "value1",
+      "key2": "value2",,
+    }`;
+
+    const offenses = await runJSONCheck(ValidJSON, invalidJson, 'file.json', {
+      jsonValidationSet: { schemas: async () => [] },
+    });
+
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal('Property expected');
+
+    const highlights = highlightedOffenses({ 'file.json': invalidJson }, offenses);
+    expect(highlights).to.have.length(1);
+    expect(highlights[0]).to.equal(',');
+  });
+
+  it('should report an error for invalid JSON (1)', async () => {
+    const invalidJson = `{
+      "key1": "value1",
+      "key2": "value2"
+    `;
+
+    const offenses = await runJSONCheck(ValidJSON, invalidJson, 'file.json', {
+      jsonValidationSet: { schemas: async () => [] },
+    });
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal('Expected comma or closing brace');
+
+    const highlights = highlightedOffenses({ 'file.json': invalidJson }, offenses);
+    expect(highlights).to.have.length(1);
+    expect(highlights[0]).to.equal('"');
+  });
+
+  it('should report an error for invalid JSON (2)', async () => {
+    const invalidJson = `{
+      'key1': "value1",
+      "key2": "value2"
+    }`;
+
+    const offenses = await runJSONCheck(ValidJSON, invalidJson, 'file.json', {
+      jsonValidationSet: { schemas: async () => [] },
+    });
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal('Property keys must be doublequoted');
+
+    const highlights = highlightedOffenses({ 'file.json': invalidJson }, offenses);
+    expect(highlights).to.have.length(1);
+    expect(highlights[0]).to.equal("'key1'");
+  });
+
+  it('should report JSON schema validation errors', async () => {
+    const invalidJson = `{
+      "myString": 10
+    }`;
+
+    const basicJsonSchema = JSON.stringify({
+      $schema: 'http://json-schema.org/draft-07/schema#',
+      type: 'object',
+      properties: {
+        myString: {
+          type: 'string',
+        },
+      },
+    });
+
+    const offenses = await runJSONCheck(ValidJSON, invalidJson, 'file.json', {
+      jsonValidationSet: {
+        schemas: async () => [
+          {
+            uri: 'https://shopify.dev/some-schema.json',
+            schema: basicJsonSchema,
+            fileMatch: ['file.json'],
+          },
+        ],
+      },
+    });
+
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal('Incorrect type. Expected "string".');
+
+    const highlights = highlightedOffenses({ 'file.json': invalidJson }, offenses);
+    expect(highlights).to.have.length(1);
+    expect(highlights[0]).to.equal('10');
+  });
+
+  it('should not report any errors for valid JSON', async () => {
+    const validJson = `{
+      "key1": "value1",
+      "key2": "value2"
+    }`;
+
+    const offenses = await runJSONCheck(ValidJSON, validJson);
+    expect(offenses).to.be.empty;
+  });
+});

package/src/checks/valid-json/index.ts

@@ -0,0 +1,34 @@
+import { JSONCheckDefinition, Severity, SourceCodeType } from '../../types';
+
+export const ValidJSON: JSONCheckDefinition = {
+  meta: {
+    code: 'ValidJSON',
+    aliases: ['ValidJson'],
+    name: 'Enforce valid JSON',
+    docs: {
+      description:
+        'This check exists to prevent invalid JSON files in themes. Will check against schema if available.',
+      recommended: true,
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/json-syntax-error',
+    },
+    type: SourceCodeType.JSON,
+    severity: Severity.ERROR,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    if (!context.validateJSON) return {};
+    const validateJSON = context.validateJSON;
+
+    return {
+      async onCodePathStart(file) {
+        const problems = await validateJSON(file.uri, file.source);
+        if (!problems) return;
+        for (const problem of problems) {
+          context.report(problem);
+        }
+      },
+    };
+  },
+};