@platformos/platformos-check-common 0.0.2

package/src/checks/json-syntax-error/index.ts

@@ -0,0 +1,92 @@
+import { ParseErrorCode, printParseErrorCode } from 'jsonc-parser';
+import { JSONCParseErrors } from '../../jsonc/parse';
+import { JSONCheckDefinition, Severity, SourceCodeType } from '../../types';
+import { isError } from '../../utils';
+
+function cleanErrorMessage(error: Error) {
+  const message = 'rawMessage' in error ? (error.rawMessage as string) : error.message;
+  return message.replace(/\s+at \d+:\d+/, '');
+}
+
+export const JSONSyntaxError: JSONCheckDefinition = {
+  meta: {
+    code: 'JSONSyntaxError',
+    name: 'Enforce valid JSON',
+    docs: {
+      description: 'This check exists to prevent invalid JSON files in themes.',
+      recommended: true,
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/json-syntax-error',
+    },
+    type: SourceCodeType.JSON,
+    severity: Severity.ERROR,
+    schema: {},
+    targets: [],
+    deprecated: true,
+  },
+
+  create(context) {
+    if (context.validateJSON) return {}; // If available, we'll use the JSON validator instead
+
+    const error = context.file.ast;
+    if (!isError(error)) return {};
+
+    return {
+      async onCodePathStart(file) {
+        if (file.ast instanceof JSONCParseErrors) {
+          for (const error of file.ast.errors) {
+            context.report({
+              message: jsoncParseErrorMessage(error.error),
+              startIndex: error.offset,
+              endIndex: error.offset + error.length,
+            });
+          }
+        } else {
+          context.report({
+            message: cleanErrorMessage(error),
+            startIndex: 0,
+            endIndex: file.source.length,
+          });
+        }
+      },
+    };
+  },
+};
+
+function jsoncParseErrorMessage(errorType: ParseErrorCode) {
+  switch (errorType) {
+    case ParseErrorCode.InvalidSymbol:
+      return 'Invalid symbol';
+    case ParseErrorCode.InvalidNumberFormat:
+      return 'Invalid number format';
+    case ParseErrorCode.PropertyNameExpected:
+      return 'Property name expected';
+    case ParseErrorCode.ValueExpected:
+      return 'Expecting a value';
+    case ParseErrorCode.ColonExpected:
+      return 'Expecting a colon after a property name (:)';
+    case ParseErrorCode.CommaExpected:
+      return 'Expecting a comma';
+    case ParseErrorCode.CloseBraceExpected:
+      return 'Expecting a closing brace (})';
+    case ParseErrorCode.CloseBracketExpected:
+      return 'Expecting a closing bracket (])';
+    case ParseErrorCode.EndOfFileExpected:
+      return 'Expecting end of file';
+    case ParseErrorCode.InvalidCommentToken:
+      return 'Invalid comment token';
+    case ParseErrorCode.UnexpectedEndOfComment:
+      return 'Unexpected end of comment';
+    case ParseErrorCode.UnexpectedEndOfString:
+      return 'Unexpected end of string';
+    case ParseErrorCode.UnexpectedEndOfNumber:
+      return 'Unexpected end of number';
+    case ParseErrorCode.InvalidUnicode:
+      return 'Invalid unicode';
+    case ParseErrorCode.InvalidEscapeCharacter:
+      return 'Invalid escape character';
+    case ParseErrorCode.InvalidCharacter:
+      return 'Invalid character';
+    default:
+      return 'Something went wrong with this JSON';
+  }
+}

package/src/checks/liquid-free-settings/index.spec.ts

@@ -0,0 +1,180 @@
+import { expect, describe, it } from 'vitest';
+import { LiquidFreeSettings } from './index';
+import { check, MockTheme } from '../../test';
+
+describe('LiquidFreeSettings validation', () => {
+  const paths = ['sections', 'blocks'];
+  paths.forEach((path) => {
+    it(`should not report errors for valid settings without liquid logic in ${path} bucket`, async () => {
+      const theme: MockTheme = {
+        [`${path}/test-section.liquid`]: `
+        {% schema %}
+        {
+          "name": "Section name",
+          "settings": [
+            {
+              "id": "text_value",
+              "type": "text",
+              "label": "Text Value",
+              "default": "Some text without liquid logic."
+            }
+          ]
+        }
+        {% endschema %}
+      `,
+      };
+
+      const offenses = await check(theme, [LiquidFreeSettings]);
+      expect(offenses).to.have.length(0);
+    });
+
+    it(`should not report errors for valid settings with dynamic source liquid logic in ${path} bucket`, async () => {
+      const theme: MockTheme = {
+        [`${path}/test-section.liquid`]: `
+        {% schema %}
+        {
+          "name": "Section name",
+          "settings": [
+            {
+              "id": "text_value",
+              "type": "text",
+              "label": "Text Value",
+              "default": "Title {{ product.title }}"
+            }
+          ]
+        }
+        {% endschema %}
+      `,
+      };
+
+      const offenses = await check(theme, [LiquidFreeSettings]);
+      expect(offenses).to.have.length(0);
+    });
+
+    it(`should report an error when settings value contains Liquid logic in ${path} bucket`, async () => {
+      const theme: MockTheme = {
+        [`${path}/test-section.liquid`]: `
+        {% schema %}
+        {
+          "name": "Section name",
+          "settings": [
+            {
+              "id": "input_with_logic",
+              "type": "text",
+              "label": "Input with Logic",
+              "default": "Hello {% if user %} User {% endif %}!"
+            }
+          ]
+        }
+        {% endschema %}
+      `,
+      };
+
+      const offenses = await check(theme, [LiquidFreeSettings]);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal('Settings values cannot contain liquid logic.');
+    });
+
+    it(`should report an error with correct indices when settings value contains Liquid logic in ${path} bucket`, async () => {
+      const theme: MockTheme = {
+        [`${path}/test-section.liquid`]: `
+        {% schema %}
+        {
+          "name": "Section name",
+          "settings": [
+            {
+              "id": "input_with_logic",
+              "type": "text",
+              "label": "Input with Logic",
+              "default": "Hello {% if user %} User {% endif %}!"
+            }
+          ]
+        }
+        {% endschema %}
+      `,
+      };
+
+      const offenses = await check(theme, [LiquidFreeSettings]);
+      expect(offenses).to.have.length(1);
+      const content = theme[`${path}/test-section.liquid`];
+      const errorContent = content.slice(offenses[0].start.index, offenses[0].end.index);
+      expect(errorContent).to.equal('"Hello {% if user %} User {% endif %}!"');
+    });
+
+    it(`should report an error when settings value contains Liquid logic in object format in ${path} bucket`, async () => {
+      const theme: MockTheme = {
+        [`${path}/test-section.liquid`]: `
+        {% schema %}
+        {
+          "name": "test",
+          "settings": {
+            "text_block": {
+              "type": "text",
+              "id": "text_block",
+              "label": "Text Block",
+              "default": "Hello {% if user %} User {% endif %}!"
+            }
+          }
+        }
+      {% endschema %}
+      `,
+      };
+
+      const offenses = await check(theme, [LiquidFreeSettings]);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal('Settings values cannot contain liquid logic.');
+    });
+
+    it(`should report errors when preset block values contain Liquid logic in ${path} bucket`, async () => {
+      const theme: MockTheme = {
+        [`${path}/test-section.liquid`]: `
+        {% schema %}
+        {
+          "name": "Section name",
+          "presets": [
+            {
+              "name": "Default",
+              "block": [
+                {
+                  "type": "text",
+                  "settings": {
+                    "text": "Hello World!{% random liquid logic %}"
+                  }
+                }
+              ]
+            }
+          ]
+        }
+        {% endschema %}
+      `,
+      };
+
+      const offenses = await check(theme, [LiquidFreeSettings]);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal('Settings values cannot contain liquid logic.');
+    });
+
+    it(`should not report errors when settings value is available_if and it contains liquid logic`, async () => {
+      const theme: MockTheme = {
+        [`${path}/test-section.liquid`]: `
+        {% schema %}
+        {
+          "name": "test",
+          "settings": {
+            "text_block": {
+              "type": "text",
+              "id": "text_block",
+              "label": "Text Block",
+              "default": "Hello World!",
+              "visible_if": "{% if user %} true {% endif %}"
+            }
+          }
+        }
+      {% endschema %}
+      `,
+      };
+      const offenses = await check(theme, [LiquidFreeSettings]);
+      expect(offenses).toEqual([]);
+    });
+  });
+});

package/src/checks/liquid-free-settings/index.ts

@@ -0,0 +1,79 @@
+import { toJSONAST } from '../../to-source-code';
+import {
+  JSONNode,
+  LiquidCheckDefinition,
+  LiteralNode,
+  Severity,
+  SourceCodeType,
+} from '../../types';
+import { visit } from '../../visitor';
+
+export const LiquidFreeSettings: LiquidCheckDefinition = {
+  meta: {
+    code: 'LiquidFreeSettings',
+    name: 'Check for liquid free settings values',
+    docs: {
+      description: 'Ensures settings values are liquid free.',
+      recommended: true,
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/liquid-free-settings',
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.WARNING,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    return {
+      async LiquidRawTag(node) {
+        if (node.name !== 'schema' || node.body.kind !== 'json') {
+          return;
+        }
+
+        const jsonString = node.source.slice(
+          node.blockStartPosition.end,
+          node.blockEndPosition.start,
+        );
+
+        const jsonFile = toJSONAST(jsonString);
+        if (jsonFile instanceof Error) return;
+
+        await visit<SourceCodeType.JSON, void>(jsonFile, {
+          async Property(schemaNode, ancestors) {
+            if (isInArrayWithParentKey(ancestors, 'settings') && isLiteralNode(schemaNode.value)) {
+              const { value, loc } = schemaNode.value;
+              const propertyValue = schemaNode.key.value;
+              if (
+                typeof value === 'string' &&
+                propertyValue !== 'visible_if' &&
+                value.includes('{%') &&
+                value.includes('%}')
+              ) {
+                context.report({
+                  message: 'Settings values cannot contain liquid logic.',
+                  startIndex: node.blockStartPosition.end + loc!.start.offset,
+                  endIndex: node.blockStartPosition.end + loc!.end.offset,
+                });
+              }
+            }
+          },
+        });
+      },
+    };
+  },
+};
+
+function isLiteralNode(node: JSONNode): node is LiteralNode {
+  return node.type === 'Literal';
+}
+
+function isInArrayWithParentKey(ancestors: JSONNode[], parentKey: string): boolean {
+  return ancestors.some((ancestor, index) => {
+    const parent = ancestors[index - 1];
+    return (
+      (ancestor.type === 'Array' || ancestor.type === 'Object') &&
+      parent?.type === 'Property' &&
+      parent.key?.value === parentKey
+    );
+  });
+}

package/src/checks/liquid-html-syntax-error/checks/InvalidBooleanExpression.spec.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import { applyFix, runLiquidCheck } from '../../../test';
+import { LiquidHTMLSyntaxError } from '..';
+
+describe('detectTrailingAssignValue', async () => {
+  it('should not report when there are no trailing values', async () => {
+    const testCases = [`{% assign foo = '123' %}`, `{% assign foo = '123' | upcase %}`];
+
+    for (const sourceCode of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).to.have.length(0);
+    }
+  });
+
+  it('should not report when the boolean expression is in a schema tag', async () => {
+    const sourceCode = `{% schema %}
+      {
+        "visible_if": "{{ this > that }}"
+      }
+    {% endschema %}`;
+
+    const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+    expect(offenses).to.have.length(0);
+  });
+
+  it('should report all use of boolean expressions', async () => {
+    const testCases = [
+      [`{% assign foo = something == else %}`, '{% assign foo = something %}'],
+      [`{% echo foo != bar %}`, '{% echo foo %}'],
+      [`{{ this > that }}`, '{{ this }}'],
+      [`{{ bool and cond }}`, '{{ bool}}'],
+    ];
+
+    for (const [sourceCode, expected] of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal('Syntax is not supported');
+
+      const fixed = applyFix(sourceCode, offenses[0]);
+      expect(fixed).to.equal(expected);
+    }
+  });
+});

package/src/checks/liquid-html-syntax-error/checks/InvalidBooleanExpressions.ts

@@ -0,0 +1,29 @@
+import { LiquidBooleanExpression, LiquidHtmlNode, NodeTypes } from '@platformos/liquid-html-parser';
+import { Problem, SourceCodeType } from '../../..';
+import { INVALID_SYNTAX_MESSAGE } from './utils';
+import { isWithinRawTagThatDoesNotParseItsContents } from '../../utils';
+
+export function detectInvalidBooleanExpressions(
+  node: LiquidBooleanExpression,
+  ancestors: LiquidHtmlNode[],
+): Problem<SourceCodeType.LiquidHtml> | undefined {
+  if (isWithinRawTagThatDoesNotParseItsContents(ancestors)) return;
+
+  const condition = node.condition;
+  if (condition.type !== NodeTypes.Comparison && condition.type !== NodeTypes.LogicalExpression) {
+    return;
+  }
+
+  return {
+    message: INVALID_SYNTAX_MESSAGE,
+    startIndex: node.position.start,
+    endIndex: node.position.end,
+    fix: (corrector) => {
+      corrector.replace(
+        node.position.start,
+        node.position.end,
+        node.source.slice(condition.left.position.start, condition.left.position.end),
+      );
+    },
+  };
+}