@platformos/platformos-check-common 0.0.6 → 0.0.8

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

@@ -1,180 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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/missing-content-for-arguments/index.spec.ts

@@ -1,144 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { applySuggestions, runLiquidCheck } from '../../test';
-import { MissingContentForArguments } from '.';
-
-function check(existingCode: string, source: string) {
-  return runLiquidCheck(
-    MissingContentForArguments,
-    source,
-    undefined,
-    {},
-    {
-      'blocks/card.liquid': existingCode,
-    },
-  );
-}
-
-const blockSourceCode = `
-  {% doc %}
-    @param {string} required_string - A required string
-    @param {number} required_number - A required number
-    @param {boolean} required_boolean - A required boolean
-    @param {object} required_object - A required object
-    @param {string} [optional_string] - An optional string
-    @param {number} [optional_number] - An optional number
-    @param {object} [optional_object] - An optional object
-    @param {boolean} [optional_boolean] - An optional boolean
-  {% enddoc %}
-`;
-
-describe('Module: MissingContentForArguments', () => {
-  describe('missing required arguments', () => {
-    it('should report missing required arguments', async () => {
-      const offenses = await check(blockSourceCode, `{% content_for 'block', type: 'card' %}`);
-
-      expect(offenses).toHaveLength(4);
-      expect(offenses[0].message).toBe(
-        "Missing required argument 'required_string' in content_for tag for static block 'card'.",
-      );
-      expect(offenses[1].message).toBe(
-        "Missing required argument 'required_number' in content_for tag for static block 'card'.",
-      );
-      expect(offenses[2].message).toBe(
-        "Missing required argument 'required_boolean' in content_for tag for static block 'card'.",
-      );
-      expect(offenses[3].message).toBe(
-        "Missing required argument 'required_object' in content_for tag for static block 'card'.",
-      );
-    });
-  });
-
-  describe('suggestions', () => {
-    it('should suggest adding missing required arguments when none already exist', async () => {
-      const sourceCode = `{% content_for 'block', type: 'card' %}`;
-      const offenses = await check(blockSourceCode, sourceCode);
-
-      expect(offenses).toHaveLength(4);
-      const x = applySuggestions(sourceCode, offenses[0]);
-      expect(x).toEqual([`{% content_for 'block', type: 'card', required_string: '' %}`]);
-    });
-  });
-
-  describe('edge cases', () => {
-    it('should handle mixed case type annotations', async () => {
-      const sourceCode = `{% content_for 'block', type: 'card', text: "hello", count: 5, flag: true, data: product %}`;
-      const offenses = await runLiquidCheck(
-        MissingContentForArguments,
-        sourceCode,
-        undefined,
-        {},
-        {
-          'blocks/card.liquid': `
-            {% doc %}
-              @param {String} text - The text
-              @param {NUMBER} count - The count
-              @param {BOOLEAN} flag - The flag
-              @param {Object} data - The data
-            {% enddoc %}
-            <div>{{ text }}{{ count }}{{ flag }}{{ data }}</div>
-          `,
-        },
-      );
-      expect(offenses).toHaveLength(0);
-    });
-
-    it('should not report when block has no doc comment', async () => {
-      const sourceCode = `{% content_for 'block', type: 'card', title: 'My Card' %}`;
-      const offenses = await runLiquidCheck(
-        MissingContentForArguments,
-        sourceCode,
-        undefined,
-        {},
-        {
-          'blocks/card.liquid': `<h1>This partial has no doc comment</h1>`,
-        },
-      );
-
-      expect(offenses).toHaveLength(0);
-    });
-
-    it('should not report when LiquidDoc definition has no defined params', async () => {
-      const sourceCode = `{% content_for 'block', type: 'card', title: 'My Card' %}`;
-      const offenses = await runLiquidCheck(
-        MissingContentForArguments,
-        sourceCode,
-        undefined,
-        {},
-        {
-          'blocks/card.liquid': `
-            {% doc %}
-              @description this is a description
-              @example this is an example
-            {% enddoc %}
-            <div>{{ title }}</div>
-            <div>{{ description }}</div>
-          `,
-        },
-      );
-
-      expect(offenses).toHaveLength(0);
-    });
-
-    it('should not report when block name is a VariableLookup', async () => {
-      const sourceCode = `{% assign block_name = 'card' %}{% content_for 'block', type: block_name, title: 'My Card' %}`;
-      const offenses = await runLiquidCheck(
-        MissingContentForArguments,
-        sourceCode,
-        undefined,
-        {},
-        {
-          'blocks/card.liquid': `
-            {% doc %}
-              @param {string} title - The title of the card
-              @param {string} description - The description of the card
-            {% enddoc %}
-            <div>{{ title }}</div>
-            <div>{{ description }}</div>
-          `,
-        },
-      );
-
-      expect(offenses).toHaveLength(0);
-    });
-  });
-});

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

@@ -1,46 +0,0 @@
-import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
-import { ContentForMarkup } from '@platformos/liquid-html-parser';
-import {
-  getBlockName,
-  getLiquidDocParams,
-  reportMissingArguments,
-} from '../../liquid-doc/arguments';
-
-export const MissingContentForArguments: LiquidCheckDefinition = {
-  meta: {
-    code: 'MissingContentForArguments',
-    name: 'Missing ContentFor Arguments',
-    docs: {
-      description:
-        'This check ensures that all required arguments are provided when rendering a static block.',
-      recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/missing-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 liquidDocParameters = await getLiquidDocParams(context, `blocks/${blockName}.liquid`);
-
-        if (!liquidDocParameters) return;
-
-        const providedParams = new Map(node.args.map((arg) => [arg.name, arg]));
-
-        const missingRequiredParams = Array.from(liquidDocParameters.values()).filter(
-          (p) => p.required && !providedParams.has(p.name),
-        );
-
-        reportMissingArguments(context, node, missingRequiredParams, blockName);
-      },
-    };
-  },
-};

package/src/checks/pagination-size/index.spec.ts

@@ -1,158 +0,0 @@
-import { expect, describe, it } from 'vitest';
-import { highlightedOffenses, runLiquidCheck } from '../../test';
-import { PaginationSize } from './index';
-
-describe('Module: PaginationSize', () => {
-  it('should report an offense when paginate size is less than minSize', async () => {
-    const sourceCode = `
-      {% paginate collection.products by 0 %}
-      {% endpaginate %}
-    `;
-    const offenses = await runLiquidCheck(PaginationSize, sourceCode);
-
-    expect(offenses).to.have.length(1);
-    expect(offenses[0].message).to.equal(
-      'Pagination size must be a positive integer between 1 and 250.',
-    );
-
-    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
-    expect(highlights).to.eql(['0']);
-  });
-
-  it('should report an offense when paginate size is greater than maxSize', async () => {
-    const sourceCode = `
-      {% paginate collection.products by 251 %}
-      {% endpaginate %}
-    `;
-
-    const offenses = await runLiquidCheck(PaginationSize, sourceCode);
-
-    expect(offenses).to.have.length(1);
-    expect(offenses[0].message).to.equal(
-      'Pagination size must be a positive integer between 1 and 250.',
-    );
-
-    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
-    expect(highlights).to.eql(['251']);
-  });
-
-  it('should not report an offense when paginate size is within the minSize and maxSize range', async () => {
-    const sourceCode = `
-      {% paginate collection.products by 25 %}
-      {% endpaginate %}
-    `;
-
-    const offenses = await runLiquidCheck(PaginationSize, sourceCode);
-    expect(offenses).to.have.length(0);
-
-    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
-    expect(highlights).to.be.empty;
-  });
-
-  it('should not report an offense when paginate size is a section setting with a valid default value', async () => {
-    const sourceCode = `
-      {% paginate collection.products by section.settings.products_per_page %}
-      {% endpaginate %}
-      {% schema %}
-        {
-          "name": "test",
-          "settings": [
-            {
-              "type": "number",
-              "id": "products_per_page",
-              "label": "Products per Page",
-              "default": 12
-            }
-          ]
-        }
-      {% endschema %}
-    `;
-
-    const offenses = await runLiquidCheck(PaginationSize, sourceCode);
-    expect(offenses).to.have.length(0);
-    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
-    expect(highlights).to.be.empty;
-  });
-
-  it('should report an offense when paginate size is a section setting with an invalid default value', async () => {
-    const sourceCode = `
-      {% paginate collection.products by section.settings.products_per_page %}
-      {% endpaginate %}
-      {% schema %}
-        {
-          "name": "test",
-          "settings": [
-            {
-              "type": "number",
-              "id": "products_per_page",
-              "label": "Products per Page",
-              "default": 251
-            }
-          ]
-        }
-      {% endschema %}
-    `;
-
-    const offenses = await runLiquidCheck(PaginationSize, sourceCode);
-    expect(offenses).to.have.length(1);
-    expect(offenses[0].message).to.equal(
-      `This setting's default value should be between 1 and 250 but is currently 251.`,
-    );
-    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
-    expect(highlights).to.eql(['section.settings.products_per_page']);
-  });
-
-  it('should report an offense when paginate size is a section setting with a missing default value', async () => {
-    const sourceCode = `
-      {% paginate collection.products by section.settings.products_per_page %}
-      {% endpaginate %}
-      {% schema %}
-        {
-          "name": "test",
-          "settings": [
-            {
-              "type": "number",
-              "id": "products_per_page",
-              "label": "Products per Page"
-            }
-          ]
-        }
-      {% endschema %}
-    `;
-
-    const offenses = await runLiquidCheck(PaginationSize, sourceCode);
-    expect(offenses).to.have.length(1);
-    expect(offenses[0].message).to.equal(
-      'Default pagination size should be defined in the section settings.',
-    );
-
-    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
-    expect(highlights).to.eql(['section.settings.products_per_page']);
-  });
-
-  it('should not report an offense when settings is not an array', async () => {
-    const sourceCode = `
-      {% paginate collection.products by section.settings.products_per_page %}
-      {% endpaginate %}
-      {% schema %}
-        {
-          "name": "test",
-          "settings": {
-            "products_per_page": {
-              "type": "number",
-              "id": "products_per_page",
-              "label": "Products per Page",
-              "default": 51
-            }
-          }
-        }
-      {% endschema %}
-    `;
-
-    const offenses = await runLiquidCheck(PaginationSize, sourceCode);
-    expect(offenses).to.have.length(0);
-
-    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
-    expect(highlights).to.be.empty;
-  });
-});