@platformos/platformos-check-common 0.0.7 → 0.0.8

package/src/checks/reserved-doc-param-names/index.ts

@@ -1,57 +0,0 @@
-import { TextNode } from '@platformos/liquid-html-parser';
-import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
-import { isBlock } from '../../to-schema';
-import {
-  REQUIRED_CONTENT_FOR_ARGUMENTS,
-  RESERVED_CONTENT_FOR_ARGUMENTS,
-} from '../../tags/content-for';
-
-export const ReservedDocParamNames: LiquidCheckDefinition = {
-  meta: {
-    code: 'ReservedDocParamNames',
-    name: 'Valid doc parameter names',
-    docs: {
-      description:
-        'This check exists to ensure any parameter names defined in LiquidDoc do not collide with reserved words.',
-      recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/reserved-doc-param-names',
-    },
-    type: SourceCodeType.LiquidHtml,
-    severity: Severity.ERROR,
-    schema: {},
-    targets: [],
-  },
-
-  create(context) {
-    if (!isBlock(context.file.uri)) {
-      return {};
-    }
-
-    const defaultParameterNames = [
-      ...REQUIRED_CONTENT_FOR_ARGUMENTS,
-      ...RESERVED_CONTENT_FOR_ARGUMENTS,
-    ];
-
-    return {
-      async LiquidDocParamNode(node) {
-        const paramName = node.paramName.value;
-
-        if (defaultParameterNames.includes(paramName)) {
-          reportWarning(
-            context,
-            `The parameter name is not supported because it's a reserved argument for 'content_for' tags.`,
-            node.paramName,
-          );
-        }
-      },
-    };
-  },
-};
-
-function reportWarning(context: any, message: string, node: TextNode) {
-  context.report({
-    message,
-    startIndex: node.position.start,
-    endIndex: node.position.end,
-  });
-}

package/src/checks/schema-presets-block-order/index.spec.ts

@@ -1,344 +0,0 @@
-import { expect, describe, it } from 'vitest';
-import { highlightedOffenses, runLiquidCheck, check } from '../../test';
-import { SchemaPresetsBlockOrder } from './index';
-
-const DEFAULT_FILE_NAME = 'sections/file.liquid';
-
-describe('Module: SchemaPresetsBlockOrder', () => {
-  it('reports no warning when the preset blocks are in the block_order', async () => {
-    const sourceCode = `
-        {% schema %}
-        {
-          "presets": [
-            {
-              "name": "Preset 1",
-              "blocks": {
-                "block-1": {
-                  "type": "text"
-                },
-                "block-2": {
-                  "type": "icon"
-                }
-              },
-              "block_order": ["block-1", "block-2"]
-            }
-          ]
-        }
-      {% endschema %}`;
-
-    const offenses = await runLiquidCheck(SchemaPresetsBlockOrder, sourceCode, DEFAULT_FILE_NAME);
-    expect(offenses).toHaveLength(0);
-  });
-
-  it('reports a warning when not all preset blocks are in the block_order', async () => {
-    const sourceCode = `
-      {% schema %}
-      {
-        "name": "Test section",
-        "presets": [
-          {
-            "name": "Preset 1",
-            "blocks": {
-              "block-1": {
-                "type": "text"
-              },
-              "block-2": {
-                "type": "icon"
-              }
-            },
-            "block_order": ["block-1"]
-          }
-        ]
-      }
-      {% endschema %}`;
-
-    const offenses = await runLiquidCheck(SchemaPresetsBlockOrder, sourceCode, DEFAULT_FILE_NAME);
-    expect(offenses).toHaveLength(1);
-    expect(offenses[0].message).toEqual("block 'block-2' is missing from the block_order");
-
-    const highlights = highlightedOffenses({ [DEFAULT_FILE_NAME]: sourceCode }, offenses);
-    expect(highlights).toHaveLength(1);
-    expect(highlights[0]).toBe('["block-1"]');
-  });
-
-  it('reports no warning when the preset blocks has static blocks that are not in the block_order', async () => {
-    const sourceCode = `
-      {% schema %}
-        {
-          "presets": [
-            {
-              "name": "Preset 1",
-              "blocks": {
-                "block-1": {
-                  "type": "text"
-                },
-                "block-2": {
-                  "type": "icon",
-                  "static": true
-                }
-              },
-              "block_order": ["block-1"]
-            }
-          ]
-        }
-        {% endschema %}`;
-
-    const offenses = await runLiquidCheck(SchemaPresetsBlockOrder, sourceCode, DEFAULT_FILE_NAME);
-    expect(offenses).toHaveLength(0);
-  });
-
-  it('reports a warning when preset blocks has static blocks that are in the block_order', async () => {
-    const sourceCode = `
-      {% schema %}
-      {
-        "presets": [
-          {
-            "name": "Preset 1",
-            "blocks": {
-              "block-1": {
-                "type": "text"
-              },
-              "block-2": {
-                "type": "icon",
-                "static": true
-              }
-            },
-            "block_order": ["block-1", "block-2"]
-          }
-        ]
-      }
-      {% endschema %}`;
-
-    const offenses = await runLiquidCheck(SchemaPresetsBlockOrder, sourceCode, DEFAULT_FILE_NAME);
-    expect(offenses).toHaveLength(1);
-    expect(offenses[0].message).toEqual("static block 'block-2' cannot be in the block_order");
-
-    const highlights = highlightedOffenses({ [DEFAULT_FILE_NAME]: sourceCode }, offenses);
-    expect(highlights).toHaveLength(1);
-    expect(highlights[0]).toBe('["block-1", "block-2"]');
-  });
-
-  it('reports no warning when the nested preset blocks are in the block_order', async () => {
-    const sourceCode = `
-      {% schema %}
-      {
-        "presets": [
-          {
-            "name": "Preset 1",
-            "blocks": {
-              "block-1": {
-                "type": "text",
-                "blocks": {
-                  "nested-1": {
-                    "type": "nested"
-                  },
-                  "nested-2": {
-                    "type": "nested"
-                  }
-                },
-                "block_order": ["nested-1", "nested-2"]
-              },
-              "block-2": {
-                "type": "icon"
-              }
-            },
-            "block_order": ["block-1", "block-2"]
-          }
-        ]
-      }
-      {% endschema %}`;
-
-    const offenses = await runLiquidCheck(SchemaPresetsBlockOrder, sourceCode, DEFAULT_FILE_NAME);
-    expect(offenses).toHaveLength(0);
-  });
-
-  it('reports a warning when the nested preset blocks are not in the block_order', async () => {
-    const sourceCode = `
-      {% schema %}
-      {
-        "presets": [
-          {
-            "name": "Preset 1",
-            "blocks": {
-              "block-1": {
-                "type": "text",
-                "blocks": {
-                  "nested-1": {
-                    "type": "nested"
-                  },
-                  "nested-2": {
-                    "type": "nested"
-                  }
-                },
-                "block_order": ["nested-1"]
-              },
-              "block-2": {
-                "type": "icon"
-              }
-            },
-            "block_order": ["block-1", "block-2"]
-          }
-        ]
-      }
-      {% endschema %}`;
-
-    const offenses = await runLiquidCheck(SchemaPresetsBlockOrder, sourceCode, DEFAULT_FILE_NAME);
-    expect(offenses).toHaveLength(1);
-    expect(offenses[0].message).toEqual("block 'nested-2' is missing from the block_order");
-
-    const highlights = highlightedOffenses({ [DEFAULT_FILE_NAME]: sourceCode }, offenses);
-    expect(highlights).toHaveLength(1);
-    expect(highlights[0]).toBe('["nested-1"]');
-  });
-
-  it('reports no warning when the nested preset blocks has static blocks that are not in the block_order', async () => {
-    const sourceCode = `
-      {% schema %}
-      {
-        "presets": [
-          {
-            "name": "Preset 1",
-            "blocks": {
-              "block-1": {
-                "type": "text",
-                "blocks": {
-                  "nested-1": {
-                    "type": "nested",
-                    "static": true
-                  },
-                  "nested-2": {
-                    "type": "nested"
-                  }
-                },
-                "block_order": ["nested-2"]
-              },
-              "block-2": {
-                "type": "icon"
-              }
-            },
-            "block_order": ["block-1", "block-2"]
-          }
-        ]
-      }
-      {% endschema %}`;
-
-    const offenses = await runLiquidCheck(SchemaPresetsBlockOrder, sourceCode, DEFAULT_FILE_NAME);
-    expect(offenses).toHaveLength(0);
-  });
-
-  it('reports a warning when the nested preset blocks has static blocks that are in the block_order', async () => {
-    const sourceCode = `
-      {% schema %}
-      {
-        "presets": [
-          {
-            "name": "Preset 1",
-            "blocks": {
-              "block-1": {
-                "type": "text",
-                "blocks": {
-                  "nested-1": {
-                    "type": "nested",
-                    "static": true
-                  },
-                  "nested-2": {
-                    "type": "nested"
-                  }
-                },
-                "block_order": ["nested-1", "nested-2"]
-              },
-              "block-2": {
-                "type": "icon"
-              }
-            },
-            "block_order": ["block-1", "block-2"]
-          }
-        ]
-      }
-      {% endschema %}`;
-
-    const offenses = await runLiquidCheck(SchemaPresetsBlockOrder, sourceCode, DEFAULT_FILE_NAME);
-    expect(offenses).toHaveLength(1);
-    expect(offenses[0].message).toEqual("static block 'nested-1' cannot be in the block_order");
-
-    const highlights = highlightedOffenses({ [DEFAULT_FILE_NAME]: sourceCode }, offenses);
-    expect(highlights).toHaveLength(1);
-    expect(highlights[0]).toBe('["nested-1", "nested-2"]');
-  });
-
-  it('reports a warning when there should be a block_order but it is missing', async () => {
-    const sourceCode = `
-      {% schema %}
-      {
-        "name": "Test section",
-        "presets": [
-          {
-            "name": "Preset 1",
-            "blocks": {
-              "block-1": {
-                "type": "text"
-              }
-            }
-          }
-        ]
-      }
-      {% endschema %}`;
-
-    const offenses = await runLiquidCheck(SchemaPresetsBlockOrder, sourceCode, DEFAULT_FILE_NAME);
-    expect(offenses).toHaveLength(1);
-    expect(offenses[0].message).toEqual('block_order is missing');
-
-    const highlights = highlightedOffenses({ [DEFAULT_FILE_NAME]: sourceCode }, offenses);
-    expect(highlights).toHaveLength(1);
-  });
-
-  it('reports no warning we have all static blocks and no block_order', async () => {
-    const sourceCode = `
-        {% schema %}
-        {
-          "presets": [
-            {
-              "name": "Preset 1",
-              "blocks": {
-                "block-1": {
-                  "type": "text",
-                  "static": true
-                }
-              }
-            }
-          ]
-        }
-      {% endschema %}`;
-
-    const offenses = await runLiquidCheck(SchemaPresetsBlockOrder, sourceCode, DEFAULT_FILE_NAME);
-    expect(offenses).toHaveLength(0);
-  });
-
-  it("reports a warning when a block in 'block_order' is not in 'blocks'", async () => {
-    const sourceCode = `
-      {% schema %}
-      {
-        "name": "Test section",
-        "presets": [
-          {
-            "name": "Preset 1",
-            "blocks": {
-              "block-1": {
-                "type": "text"
-              }
-            },
-            "block_order": ["block-1", "block-2"]
-          }
-        ]
-      }
-      {% endschema %}`;
-
-    const offenses = await runLiquidCheck(SchemaPresetsBlockOrder, sourceCode, DEFAULT_FILE_NAME);
-    expect(offenses).toHaveLength(1);
-    expect(offenses[0].message).toEqual("block 'block-2' is missing from 'blocks'");
-
-    const highlights = highlightedOffenses({ [DEFAULT_FILE_NAME]: sourceCode }, offenses);
-    expect(highlights).toHaveLength(1);
-    expect(highlights[0]).toBe('"block-2"');
-  });
-});

package/src/checks/schema-presets-block-order/index.ts

@@ -1,154 +0,0 @@
-import { getLocEnd, getLocStart, nodeAtPath } from '../../json';
-import { getSchema } from '../../to-schema';
-import {
-  ArrayNode,
-  Context,
-  JSONNode,
-  LiquidCheckDefinition,
-  Severity,
-  SourceCodeType,
-} from '../../types';
-import { Preset } from '../../types/schemas/preset';
-
-export const SchemaPresetsBlockOrder: LiquidCheckDefinition = {
-  meta: {
-    code: 'SchemaPresetsBlockOrder',
-    name: 'Gives recommendations and validations for block_order',
-    docs: {
-      description:
-        'Gives recommendations and validations for block_order for preset blocks as a hash.',
-      recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/schema-presets-block-order',
-    },
-    type: SourceCodeType.LiquidHtml,
-    severity: Severity.WARNING,
-    schema: {},
-    targets: [],
-  },
-
-  create(context) {
-    return {
-      async LiquidRawTag(node) {
-        if (node.name !== 'schema' || node.body.kind !== 'json') {
-          return;
-        }
-
-        const offset = node.blockStartPosition.end;
-        const schema = await getSchema(context);
-        const { validSchema, ast } = schema ?? {};
-        if (!validSchema || validSchema instanceof Error) return;
-        if (!ast || ast instanceof Error) return;
-
-        const presets = validSchema.presets;
-        if (!presets) return;
-
-        presets.forEach((preset, index) => {
-          if ('blocks' in preset && preset.blocks) {
-            checkBlockOrder(preset, context, offset, ast, ['presets', String(index)]);
-          }
-        });
-      },
-    };
-  },
-};
-
-function checkBlockOrder(
-  node: Preset.Preset | Preset.PresetBlockForHash,
-  context: Context<SourceCodeType.LiquidHtml>,
-  offset: number,
-  ast: JSONNode,
-  ast_path: string[],
-) {
-  if ('blocks' in node && typeof node.blocks == 'object' && node.blocks) {
-    const blockOrder = 'block_order' in node ? node.block_order : undefined;
-    // check 1: is block_order missing?
-    if (!blockOrder) {
-      if (shouldHaveBlockOrder(node)) {
-        reportWarning(context, offset, ast, ast_path, `block_order is missing`, false);
-      }
-    }
-
-    // check 2: are items in block_order present in blocks?
-    blockOrder?.forEach((block_id, index) => {
-      if (!node.blocks || (!Array.isArray(node.blocks) && !node.blocks[block_id])) {
-        const warning_ast_path = ast_path.concat(['block_order']).concat([String(index)]);
-        reportWarning(
-          context,
-          offset,
-          ast,
-          warning_ast_path,
-          `block '${block_id}' is missing from 'blocks'`,
-        );
-      }
-    });
-
-    // check 3: are items in blocks correctly in block_order?
-    for (const [block_id, block] of Object.entries(node.blocks)) {
-      if (block.static) {
-        // if static block is in the block_order, that's an error
-        if (Array.isArray(blockOrder) && blockOrder.includes(block_id)) {
-          const warning_ast_path = ast_path.concat(['block_order']);
-          reportWarning(
-            context,
-            offset,
-            ast,
-            warning_ast_path,
-            `static block '${block_id}' cannot be in the block_order`,
-          );
-        }
-      } else {
-        // if non-static block is not in the block_order, that's a potential mistake
-        if (Array.isArray(blockOrder) && !blockOrder.includes(block_id)) {
-          const warning_ast_path = ast_path.concat(['block_order']);
-          reportWarning(
-            context,
-            offset,
-            ast,
-            warning_ast_path,
-            `block '${block_id}' is missing from the block_order`,
-          );
-        }
-      }
-
-      //recursive check for nested blocks
-      if (block.blocks) {
-        ast_path.push('blocks', block_id); // so we'll get ['presets', 0, 'blocks', 'my_block1'] for example to do nodeAtPath(schema.ast, ast_path)
-        checkBlockOrder(block, context, offset, ast, ast_path);
-      }
-    }
-  }
-}
-
-function shouldHaveBlockOrder(node: Preset.Preset | Preset.PresetBlockForHash): boolean {
-  if (
-    'blocks' in node &&
-    typeof node.blocks === 'object' &&
-    node.blocks !== null &&
-    !Array.isArray(node.blocks)
-  ) {
-    return Object.entries(node.blocks).some(([_blockId, block]) => {
-      // If static is undefined or false, it's considered non-static
-      return block.static !== true;
-    });
-  }
-
-  return false;
-}
-
-function reportWarning(
-  context: Context<SourceCodeType.LiquidHtml>,
-  offset: number,
-  ast: JSONNode,
-  ast_path: string[],
-  message: string,
-  fullHighlight: boolean = true,
-) {
-  const node = nodeAtPath(ast, ast_path)! as ArrayNode;
-  const startIndex = fullHighlight ? offset + getLocStart(node) : offset + getLocEnd(node) - 1; // start to finish of the node or last char of the node
-  const endIndex = offset + getLocEnd(node);
-  context.report({
-    message: message,
-    startIndex,
-    endIndex,
-  });
-}

package/src/checks/schema-presets-static-blocks/index.spec.ts

@@ -1,145 +0,0 @@
-import { expect, describe, it } from 'vitest';
-import { highlightedOffenses, runLiquidCheck, check } from '../../test';
-import { SchemaPresetsStaticBlocks } from './index';
-
-const DEFAULT_FILE_NAME = 'sections/file.liquid';
-
-describe('Module: SchemaPresetsStaticBlocks', () => {
-  it('reports no errors when there are {% content_for "block" ... %} for each static block in the preset blocks array', async () => {
-    const sourceCode = `
-      {% content_for "block" type:"text" id: "block-1" %}
-      {% content_for "block" type:"icon" id: "block-2" %}
-      {% schema %}
-      {
-        "name": "Test section",
-        "blocks": [{"type": "@theme"}],
-        "presets": [
-          {
-            "name": "Preset with two static blocks",
-            "blocks": [
-              {
-                "type": "text",
-                "static": true,
-                "id": "block-1"
-              },
-              {
-                "type": "icon",
-                "static": true,
-                "id": "block-2"
-              }
-            ]
-          }
-        ]
-      }
-      {% endschema %}`;
-
-    const offenses = await runLiquidCheck(SchemaPresetsStaticBlocks, sourceCode, DEFAULT_FILE_NAME);
-    expect(offenses).toHaveLength(0);
-  });
-
-  it('reports an error when there are {% content_for "block" ... %} missing for static blocks in the preset blocks array', async () => {
-    const sourceCode = `
-      {% content_for "block" type:"text" id:"block-1" %}
-      {% comment %} here we are missing the other content_for block for block-2 {% endcomment %}
-      {% schema %}
-      {
-        "name": "Test section",
-        "blocks": [{"type": "@theme"}],
-        "presets": [
-          {
-            "name": "Preset with two static blocks",
-            "blocks": [
-              {
-                "type": "text",
-                "static": true,
-                "id": "block-1"
-              },
-              {
-                "type": "icon",
-                "static": true,
-                "id": "block-2"
-              }
-            ]
-          }
-        ]
-      }
-      {% endschema %}`;
-
-    const offenses = await runLiquidCheck(SchemaPresetsStaticBlocks, sourceCode, DEFAULT_FILE_NAME);
-    expect(offenses).toHaveLength(1);
-    console.log(offenses);
-    expect(offenses[0].message).toEqual(
-      'Static block block-2 is missing a corresponding content_for "block" tag.',
-    );
-
-    const highlights = highlightedOffenses({ [DEFAULT_FILE_NAME]: sourceCode }, offenses);
-    expect(highlights).toHaveLength(1);
-  });
-
-  it('reports no errors when there are {% content_for "block" ... %} for each static block in the preset blocks hash', async () => {
-    const sourceCode = `
-      {% content_for "block" type:"text" id: "block-1" %}
-      {% content_for "block" type:"icon" id: "block-2" %}
-      {% schema %}
-      {
-        "name": "Test section",
-        "blocks": [{"type": "@theme"}],
-        "presets": [
-          {
-            "name": "Preset with two static blocks",
-            "blocks": {
-              "block-1": {
-                "type": "text",
-                "static": true
-              },
-              "block-2": {
-                "type": "icon",
-                "static": true
-              }
-            }
-          }
-        ]
-      }
-      {% endschema %}`;
-
-    const offenses = await runLiquidCheck(SchemaPresetsStaticBlocks, sourceCode, DEFAULT_FILE_NAME);
-    expect(offenses).toHaveLength(0);
-  });
-
-  it('reports an error when there are {% content_for "block" ... %} missing for static blocks in the preset blocks hash', async () => {
-    const sourceCode = `
-      {% content_for "block" type:"text" id:"block-1" %}
-      {% comment %} here we are missing the other content_for block for block-2 {% endcomment %}
-      {% schema %}
-      {
-        "name": "Test section",
-        "blocks": [{"type": "@theme"}],
-        "presets": [
-          {
-            "name": "Preset with two static blocks",
-            "blocks": {
-              "block-1": {
-                "type": "text",
-                "static": true
-              },
-              "block-2": {
-                "type": "icon",
-                "static": true
-              }
-            }
-          }
-        ]
-      }
-      {% endschema %}`;
-
-    const offenses = await runLiquidCheck(SchemaPresetsStaticBlocks, sourceCode, DEFAULT_FILE_NAME);
-    expect(offenses).toHaveLength(1);
-    console.log(offenses);
-    expect(offenses[0].message).toEqual(
-      'Static block block-2 is missing a corresponding content_for "block" tag.',
-    );
-
-    const highlights = highlightedOffenses({ [DEFAULT_FILE_NAME]: sourceCode }, offenses);
-    expect(highlights).toHaveLength(1);
-  });
-});