@platformos/platformos-check-common 0.0.2

package/src/checks/valid-local-blocks/index.spec.ts

@@ -0,0 +1,286 @@
+import { expect, describe, it } from 'vitest';
+import { ValidLocalBlocks } from './index';
+import { check, MockTheme } from '../../test';
+
+describe('ValidLocalBlocks with array-style blocks', () => {
+  it('should report errors when root level local blocks are defined in a block bucket', async () => {
+    const theme: MockTheme = {
+      'blocks/local-blocks.liquid': `
+        {% schema %}
+        {
+            "name": "Block name",
+            "blocks": [
+            {
+                "type": "local_block",
+                "name": "Local Block"
+            }
+            ]
+        }
+        {% endschema %}
+        `,
+    };
+
+    const offenses = await check(theme, [ValidLocalBlocks]);
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal('Local scoped blocks are not supported in theme blocks.');
+  });
+
+  it('should report errors when sections use theme blocks together with locally scoped blocks in root level', async () => {
+    const theme: MockTheme = {
+      'blocks/text.liquid': '',
+      'sections/local-blocks.liquid': `
+        {% schema %}
+        {
+            "name": "Section name",
+            "blocks": [
+            {
+                "type": "text"
+            },
+            {
+                "type": "local_block",
+                "name": "Local Block"
+            }
+            ]
+        }
+        {% endschema %}
+        `,
+    };
+    const offenses = await check(theme, [ValidLocalBlocks]);
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal(
+      'Sections cannot use theme blocks together with locally scoped blocks.',
+    );
+  });
+
+  it('should report errors when sections use static theme blocks together with locally scoped blocks', async () => {
+    const theme: MockTheme = {
+      'sections/local-blocks.liquid': `
+            {% schema %}
+            {
+                "name": "Section name",
+                "blocks": [
+                {
+                    "type": "local_block",
+                    "name": "Local Block"
+                }
+                ],
+                "presets": [
+                {
+                    "name": "Default",
+                    "blocks": [
+                    {
+                        "id": "static_block",
+                        "type": "static_block",
+                        "static": true
+                    }
+                    ]
+                }
+                ]
+            }
+            {% endschema %}
+            `,
+    };
+    const offenses = await check(theme, [ValidLocalBlocks]);
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal(
+      'Sections cannot use static theme blocks together with locally scoped blocks.',
+    );
+  });
+
+  it('should report errors with correct indices when sections use static theme blocks together with locally scoped blocks', async () => {
+    const theme: MockTheme = {
+      'sections/local-blocks.liquid': `
+                {% schema %}
+                {
+                "name": "Section name",
+                "blocks": [
+                    {
+                    "type": "local_block",
+                    "name": "Local Block"
+                    }
+                ],
+                "presets": [
+                    {
+                    "name": "Default",
+                    "blocks": [
+                        {
+                        "id": "static_block",
+                        "type": "static_block",
+                        "static": true
+                        }
+                    ]
+                    }
+                ]
+                }
+                {% endschema %}
+            `,
+    };
+    const offenses = await check(theme, [ValidLocalBlocks]);
+    expect(offenses).to.have.length(1);
+
+    const content = theme['sections/local-blocks.liquid'];
+    const errorContent = content.slice(offenses[0].start.index, offenses[0].end.index);
+    expect(errorContent).to.equal('"static_block"');
+  });
+});
+
+describe('ValidLocalBlocks on edge cases', () => {
+  it('should not report errors for block setting types', async () => {
+    const theme: MockTheme = {
+      'sections/local-blocks.liquid': `
+        {% schema %}
+        {
+          "name": "Section name",
+          "blocks": [
+            {
+              "type": "@app"
+            },
+            {
+              "type": "link_list",
+              "name": "Link list",
+              "settings": [
+                {
+                  "type": "inline_richtext",
+                  "id": "heading",
+                  "default": "Heading"
+                },
+                {
+                  "type": "link_list",
+                  "id": "menu",
+                  "default": "Footer"
+                }
+              ]
+            }
+          ]
+        }
+        {% endschema %}
+      `,
+    };
+
+    const offenses = await check(theme, [ValidLocalBlocks]);
+    expect(offenses).to.be.empty;
+  });
+
+  it('should not report errors when @app is used alongside static blocks', async () => {
+    const theme: MockTheme = {
+      'sections/local-blocks.liquid': `
+        {% schema %}
+        {
+          "name": "Section name",
+          "blocks": [
+            {
+              "type": "@app"
+            },
+            {
+              "type": "static_block",
+              "static": true
+            }
+          ]
+        }
+        {% endschema %}
+      `,
+    };
+
+    const offenses = await check(theme, [ValidLocalBlocks]);
+    expect(offenses).to.be.empty;
+  });
+
+  it('should not report errors on themes that define local blocks at the root level and use them in presets', async () => {
+    const theme: MockTheme = {
+      'sections/local-blocks.liquid': `
+        {% schema %}
+        {
+          "name": "Section name",
+          "blocks": [
+            {
+              "type": "local_block",
+              "name": "Local Block"
+            }
+          ],
+          "presets": [
+            {
+              "name": "Default",
+              "blocks": [
+                {
+                  "type": "local_block"
+                }
+              ]
+            }
+          ]
+        }
+        {% endschema %}
+      `,
+    };
+
+    const offenses = await check(theme, [ValidLocalBlocks]);
+    expect(offenses).to.be.empty;
+  });
+
+  it('should not report errors on older themes that define local blocks at the root level and use them in hash-style presets', async () => {
+    const theme: MockTheme = {
+      'sections/local-blocks.liquid': `
+        {% schema %}
+        {
+          "name": "Section name",
+          "blocks": [
+            {
+              "type": "local_block",
+              "name": "Local Block"
+            }
+          ],
+          "presets": [
+            {
+              "name": "Default",
+              "blocks": {
+                "local_block": {
+                  "type": "local_block"
+                }
+              }
+            }
+          ]
+        }
+        {% endschema %}
+      `,
+    };
+    const offenses = await check(theme, [ValidLocalBlocks]);
+    expect(offenses).to.be.empty;
+  });
+
+  it('should not report errors when preset blocks have a name property', async () => {
+    const theme: MockTheme = {
+      'blocks/product-grid.liquid': `
+      {% schema %}
+      {
+        "name": "Product grid",
+        "blocks": [{ "type": "product-card" }],
+        "presets": [
+          {
+            "name": "Product grid",
+            "blocks": {
+              "product-grid-card": {
+                "type": "product-card",
+                "static": true,
+                "blocks": {
+                  "card_gallery_eK4Hr7": {
+                    "type": "card-gallery",
+                    "name": "potato",
+                  },
+                  "group_4RMFLV": {
+                    "type": "group"
+                  }
+                },
+                "block_order": ["card_gallery_eK4Hr7", "group_4RMFLV"]
+              }
+            }
+          }
+        ]
+      }
+      {% endschema %}
+
+      `,
+    };
+
+    const offenses = await check(theme, [ValidLocalBlocks]);
+    expect(offenses).to.be.empty;
+  });
+});

package/src/checks/valid-local-blocks/index.ts

@@ -0,0 +1,100 @@
+import {
+  LiquidCheckDefinition,
+  Preset,
+  Severity,
+  SourceCodeType,
+  Section,
+  LiteralNode,
+} from '../../types';
+import { nodeAtPath } from '../../json';
+import { getSchema } from '../../to-schema';
+import { isBlock, isSection } from '../../to-schema';
+import { getBlocks, reportWarning } from './valid-block-utils';
+
+type BlockNodeWithPath = {
+  node: Section.Block | Preset.Block;
+  path: string[];
+};
+
+export const ValidLocalBlocks: LiquidCheckDefinition = {
+  meta: {
+    code: 'ValidLocalBlocks',
+    name: 'Prevent mixing static and local blocks in non-theme sections',
+    docs: {
+      description:
+        'Ensures sections without theme block support do not mix static and local blocks',
+      recommended: true,
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/valid-local-blocks',
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.ERROR,
+    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;
+        if (!schema) return;
+
+        const {
+          staticBlockLocations,
+          localBlockLocations,
+          themeBlockLocations,
+          hasRootLevelThemeBlocks,
+        } = getBlocks(validSchema);
+
+        if (isSection(context.file.uri)) {
+          if (staticBlockLocations.length > 0 && localBlockLocations.length > 0) {
+            staticBlockLocations.forEach((blockWithPath: BlockNodeWithPath) => {
+              const astNode = nodeAtPath(ast, blockWithPath.path)! as LiteralNode;
+              reportWarning(
+                `Sections cannot use static theme blocks together with locally scoped blocks.`,
+                offset,
+                astNode,
+                context,
+              );
+            });
+          }
+
+          if (
+            hasRootLevelThemeBlocks &&
+            localBlockLocations.length > 0 &&
+            themeBlockLocations.length > 0
+          ) {
+            localBlockLocations.forEach((blockWithPath: BlockNodeWithPath) => {
+              const astNode = nodeAtPath(ast, blockWithPath.path)! as LiteralNode;
+              reportWarning(
+                'Sections cannot use theme blocks together with locally scoped blocks.',
+                offset,
+                astNode,
+                context,
+              );
+            });
+          }
+        }
+
+        if (isBlock(context.file.uri)) {
+          if (localBlockLocations.length > 0) {
+            localBlockLocations.forEach((blockWithPath: BlockNodeWithPath) => {
+              const astNode = nodeAtPath(ast, blockWithPath.path)! as LiteralNode;
+              reportWarning(
+                'Local scoped blocks are not supported in theme blocks.',
+                offset,
+                astNode,
+                context,
+              );
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/src/checks/valid-local-blocks/valid-block-utils.ts

@@ -0,0 +1,97 @@
+import { getLocEnd, getLocStart } from '../../json';
+import { Preset, ThemeBlock, Section, Context, SourceCodeType, LiteralNode } from '../../types';
+
+type BlockNodeWithPath = {
+  node: Section.Block | ThemeBlock.Block | Preset.Block;
+  path: string[];
+};
+
+export function getBlocks(validSchema: ThemeBlock.Schema | Section.Schema): {
+  staticBlockLocations: BlockNodeWithPath[];
+  localBlockLocations: BlockNodeWithPath[];
+  themeBlockLocations: BlockNodeWithPath[];
+  hasRootLevelThemeBlocks: boolean;
+} {
+  const staticBlockLocations: BlockNodeWithPath[] = [];
+  const localBlockLocations: BlockNodeWithPath[] = [];
+  const themeBlockLocations: BlockNodeWithPath[] = [];
+
+  const rootLevelBlocks = validSchema.blocks;
+  const presets = validSchema.presets;
+
+  function categorizeBlock(
+    block: Section.Block | ThemeBlock.Block | Preset.Block,
+    currentPath: string[],
+    inPreset: boolean = false,
+  ) {
+    if (!block) return;
+    const hasStatic = 'static' in block;
+    const hasName = 'name' in block;
+
+    if (hasStatic) {
+      staticBlockLocations.push({ node: block, path: currentPath.concat('type') });
+    } else if (hasName && !inPreset) {
+      localBlockLocations.push({ node: block, path: currentPath.concat('type') });
+    } else if (block.type !== '@app') {
+      themeBlockLocations.push({ node: block, path: currentPath.concat('type') });
+    }
+
+    if ('blocks' in block) {
+      if (Array.isArray(block.blocks)) {
+        block.blocks.forEach((nestedBlock: Preset.PresetBlockForArray, index: number) => {
+          categorizeBlock(nestedBlock, currentPath.concat('blocks', String(index)), inPreset);
+        });
+      } else if (typeof block.blocks === 'object' && block.blocks !== null) {
+        Object.entries(block.blocks).forEach(([key, nestedBlock]) => {
+          categorizeBlock(nestedBlock, currentPath.concat('blocks', key), inPreset);
+        });
+      }
+    }
+  }
+
+  if (Array.isArray(rootLevelBlocks)) {
+    rootLevelBlocks.forEach((block, index) => {
+      categorizeBlock(block, ['blocks', String(index)]);
+    });
+  }
+
+  if (presets) {
+    presets.forEach((preset: Preset.Preset, presetIndex: number) => {
+      if ('blocks' in preset && preset.blocks) {
+        if (Array.isArray(preset.blocks)) {
+          preset.blocks.forEach((block: Preset.PresetBlockForArray, blockIndex: number) => {
+            categorizeBlock(
+              block,
+              ['presets', String(presetIndex), 'blocks', String(blockIndex)],
+              true,
+            );
+          });
+        } else if (typeof preset.blocks === 'object') {
+          Object.entries(preset.blocks).forEach(([key, block]) => {
+            categorizeBlock(block, ['presets', String(presetIndex), 'blocks', key], true);
+          });
+        }
+      }
+    });
+  }
+
+  return {
+    staticBlockLocations,
+    localBlockLocations,
+    themeBlockLocations,
+    hasRootLevelThemeBlocks: themeBlockLocations.some((block) => block.path[0] === 'blocks'),
+  };
+}
+
+export function reportWarning(
+  message: string,
+  offset: number,
+  astNode: LiteralNode,
+  context: Context<SourceCodeType.LiquidHtml>,
+) {
+  context.report({
+    message,
+    startIndex: offset + getLocStart(astNode),
+    endIndex: offset + getLocEnd(astNode),
+  });
+}