@platformos/platformos-check-common 0.0.2

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

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

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

@@ -0,0 +1,145 @@
+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);
+  });
+});