@platformos/platformos-check-common 0.0.2

package/src/checks/json-missing-block/index.spec.ts

@@ -0,0 +1,435 @@
+import { expect, describe, it } from 'vitest';
+import { JSONMissingBlock } from './index';
+import { check, MockTheme } from '../../test';
+
+describe('Module: JsonMissingBlock', () => {
+  describe('File existence validation', () => {
+    it('should report an offense when a block does not exist', async () => {
+      const theme: MockTheme = {
+        'templates/product.failing.json': `{
+          "sections": {
+            "custom-section": {
+              "type": "custom-section",
+              "blocks": {
+                "text_tqQTNE": {
+                  "type": "missing_block"
+                }
+              },
+              "block_order": ["text_tqQTNE"]
+            }
+          },
+          "order": ["custom-section"]
+        }`,
+        'sections/custom-section.liquid': `
+          {% schema %}
+          {
+            "name": "Custom Section",
+            "blocks": [
+              {
+                "type": "missing_block"
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+      };
+
+      const offenses = await check(theme, [JSONMissingBlock]);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal(
+        "Theme block 'blocks/missing_block.liquid' does not exist.",
+      );
+
+      const content = theme['templates/product.failing.json'];
+      const erroredContent = content.slice(offenses[0].start.index, offenses[0].end.index);
+      expect(erroredContent).to.equal('"missing_block"');
+    });
+
+    it('should not report an offense when block exists', async () => {
+      const theme: MockTheme = {
+        'templates/product.valid.json': `{
+          "sections": {
+            "custom-section": {
+              "type": "custom-section",
+              "blocks": {
+                "text_block": {
+                  "type": "text"
+                }
+              },
+              "block_order": ["text_block"]
+            }
+          },
+          "order": ["custom-section"]
+        }`,
+        'sections/custom-section.liquid': `
+          {% schema %}
+          {
+            "name": "Custom Section",
+            "blocks": [
+              {
+                "type": "text"
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+        'blocks/text.liquid': '',
+      };
+
+      const offenses = await check(theme, [JSONMissingBlock]);
+      expect(offenses).to.be.empty;
+    });
+
+    it('should report an offense when a nested block does not exist', async () => {
+      const theme: MockTheme = {
+        'templates/product.nested.json': `{
+          "sections": {
+            "custom-section": {
+              "type": "custom-section",
+              "blocks": {
+                "parent_block": {
+                  "type": "text",
+                  "blocks": {
+                    "child_block": {
+                      "type": "missing_nested"
+                    }
+                  }
+                }
+              },
+              "block_order": ["parent_block"]
+            }
+          },
+          "order": ["custom-section"]
+        }`,
+        'sections/custom-section.liquid': `
+          {% schema %}
+          {
+            "name": "Custom Section",
+            "blocks": [
+              {
+                "type": "text"
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+        'blocks/text.liquid': `
+        {% schema %}
+          {
+            "name": "Text Block",
+            "blocks": [
+              {
+                "type": "missing_nested"
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+      };
+
+      const offenses = await check(theme, [JSONMissingBlock]);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal(
+        "Theme block 'blocks/missing_nested.liquid' does not exist.",
+      );
+
+      const content = theme['templates/product.nested.json'];
+      const erroredContent = content.slice(offenses[0].start.index, offenses[0].end.index);
+      expect(erroredContent).to.equal('"missing_nested"');
+    });
+  });
+
+  describe('Allowed block type validation', () => {
+    it('should report an offense when block exists but is not in the section liquid schema', async () => {
+      const theme: MockTheme = {
+        'templates/product.valid.json': `{
+          "sections": {
+            "custom-section": {
+              "type": "custom-section",
+              "blocks": {
+                "text_block": {
+                  "type": "text"
+                }
+              },
+              "block_order": ["text_block"]
+            }
+          },
+          "order": ["custom-section"]
+        }`,
+        'sections/custom-section.liquid': `
+          {% schema %}
+          {
+            "name": "Custom Section",
+            "blocks": [
+              {
+                "type": "image"
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+        'blocks/text.liquid': '',
+        'blocks/image.liquid': '',
+      };
+
+      const offenses = await check(theme, [JSONMissingBlock]);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal(
+        "Block type 'text' is not allowed in 'sections/custom-section.liquid'.",
+      );
+
+      const content = theme['templates/product.valid.json'];
+      const erroredContent = content.slice(offenses[0].start.index, offenses[0].end.index);
+      expect(erroredContent).to.equal('"text"');
+    });
+
+    it('should report an offense when a nested block exists but is not in the block liquid schema', async () => {
+      const theme: MockTheme = {
+        'templates/product.nested.json': `{
+          "sections": {
+            "custom-section": {
+              "type": "custom-section",
+              "blocks": {
+                "parent_block": {
+                  "type": "text",
+                  "blocks": {
+                    "child_block": {
+                      "type": "missing_nested"
+                    }
+                  }
+                }
+              },
+              "block_order": ["parent_block"]
+            }
+          },
+          "order": ["custom-section"]
+        }`,
+        'sections/custom-section.liquid': `
+          {% schema %}
+          {
+            "name": "Custom Section",
+            "blocks": [
+              {
+                "type": "text"
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+        'blocks/text.liquid': `
+        {% schema %}
+          {
+            "name": "Text Block",
+            "blocks": [
+              {
+                "type": "image"
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+        'blocks/image.liquid': '',
+        'blocks/missing_nested.liquid': '',
+      };
+
+      const offenses = await check(theme, [JSONMissingBlock]);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal(
+        "Block type 'missing_nested' is not allowed in 'blocks/text.liquid'.",
+      );
+
+      const content = theme['templates/product.nested.json'];
+      const erroredContent = content.slice(offenses[0].start.index, offenses[0].end.index);
+      expect(erroredContent).to.equal('"missing_nested"');
+    });
+
+    it('should report an offense when a nested private block exists but is not in the block liquid schema', async () => {
+      const theme: MockTheme = {
+        'templates/product.nested.json': `{
+          "sections": {
+            "custom-section": {
+              "type": "custom-section",
+              "blocks": {
+                "parent_block": {
+                  "type": "text",
+                  "blocks": {
+                    "child_block": {
+                      "type": "_private_block"
+                    }
+                  }
+                }
+              },
+              "block_order": ["parent_block"]
+            }
+          },
+          "order": ["custom-section"]
+        }`,
+        'sections/custom-section.liquid': `
+          {% schema %}
+          {
+            "name": "Custom Section",
+            "blocks": [
+              {
+                "type": "text"
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+        'blocks/text.liquid': `
+        {% schema %}
+          {
+            "name": "Text Block",
+            "blocks": [
+              {
+                "type": "@theme"
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+        'blocks/image.liquid': '',
+        'blocks/_private_block.liquid': '',
+      };
+
+      const offenses = await check(theme, [JSONMissingBlock]);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal(
+        "Block type '_private_block' is not allowed in 'blocks/text.liquid'.",
+      );
+
+      const content = theme['templates/product.nested.json'];
+      const erroredContent = content.slice(offenses[0].start.index, offenses[0].end.index);
+      expect(erroredContent).to.equal('"_private_block"');
+    });
+
+    it('should not report an offense when a static block exists and is not in the block liquid schema', async () => {
+      const theme: MockTheme = {
+        'templates/product.static.json': `{
+          "sections": {
+            "custom-section": {
+              "type": "custom-section",
+              "blocks": {
+                "child_block": {
+                  "type": "text"
+                },
+                "static_block": {
+                  "type": "static_block",
+                  "static": true
+                }
+              },
+              "block_order": ["child_block"]
+            }
+          },
+          "order": ["custom-section"]
+        }`,
+        'sections/custom-section.liquid': `
+          {% schema %}
+          {
+            "name": "Custom Section",
+            "blocks": [
+              {
+                "type": "text"
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+        'blocks/text.liquid': `
+        {% schema %}
+          {
+            "name": "Text Block",
+            "blocks": [
+              {
+                "type": "@theme"
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+        'blocks/static_block.liquid': `
+        {% schema %}
+          {
+            "name": "Static Block",
+          }
+          {% endschema %}
+        `,
+      };
+
+      const offenses = await check(theme, [JSONMissingBlock]);
+      expect(offenses).to.have.length(0);
+    });
+  });
+
+  describe('Edge case validation', () => {
+    it('should ignore non-template JSON files', async () => {
+      const theme: MockTheme = {
+        'config/index.json': `{
+          "blocks": {
+            "text_block": {
+              "type": "nonexistent"
+            }
+          }
+        }`,
+      };
+
+      const offenses = await check(theme, [JSONMissingBlock]);
+      expect(offenses).to.be.empty;
+    });
+
+    it('should ignore templates with local blocks', async () => {
+      const theme: MockTheme = {
+        'templates/product.nested.json': `{
+          "sections": {
+            "custom-section": {
+              "type": "custom-section",
+              "blocks": {
+                "parent_block": {
+                  "type": "text",
+                  "blocks": {
+                    "child_block": {
+                      "type": "_private_block"
+                    }
+                  }
+                }
+              },
+              "block_order": ["parent_block"]
+            }
+          },
+          "order": ["custom-section"]
+        }`,
+        'sections/custom-section.liquid': `
+          {% schema %}
+          {
+            "name": "Custom Section",
+            "blocks": [
+              {
+                "type": "text",
+                "name": "Text Block"
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+        'blocks/text.liquid': `
+        {% schema %}
+          {
+            "name": "Text Block",
+            "blocks": [
+              {
+                "type": "image",
+                "name": "Image Block"
+              }
+            ]
+          }
+          {% endschema %}
+        `,
+        'blocks/image.liquid': '',
+        'blocks/_private_block.liquid': '',
+      };
+
+      const offenses = await check(theme, [JSONMissingBlock]);
+      expect(offenses).to.be.empty;
+    });
+  });
+});

package/src/checks/json-missing-block/index.ts

@@ -0,0 +1,56 @@
+import { getSchemaFromJSON } from '../../to-schema';
+import { JSONCheckDefinition, Severity, SourceCodeType } from '../../types';
+import { getAllBlocks, isPropertyNode } from './missing-block-utils';
+
+export const JSONMissingBlock: JSONCheckDefinition = {
+  meta: {
+    code: 'JSONMissingBlock',
+    name: 'Check for missing blocks types in JSON templates',
+    docs: {
+      description: 'This check ensures that JSON templates contain valid block types.',
+      recommended: true,
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/json-missing-block',
+    },
+    type: SourceCodeType.JSON,
+    severity: Severity.ERROR,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    const relativePath = context.toRelativePath(context.file.uri);
+    if (!relativePath.startsWith('templates/')) return {};
+
+    return {
+      async onCodePathEnd() {
+        const schema = await getSchemaFromJSON(context);
+        const { ast } = schema ?? {};
+        if (!ast || ast instanceof Error) return;
+        if (!schema) return;
+
+        const sections = schema.parsed.sections;
+        if (!sections) return;
+
+        await Promise.all(
+          Object.entries(sections).map(async ([sectionKey, section]) => {
+            if (
+              isPropertyNode(section) &&
+              'blocks' in section &&
+              isPropertyNode(section.blocks) &&
+              'type' in section
+            ) {
+              await getAllBlocks(
+                ast,
+                0,
+                section.type,
+                section.blocks,
+                ['sections', sectionKey, 'blocks'],
+                context,
+              );
+            }
+          }),
+        );
+      },
+    };
+  },
+};

package/src/checks/json-missing-block/missing-block-utils.ts

@@ -0,0 +1,147 @@
+import { Context, SourceCodeType, JSONNode } from '../../types';
+import { PropertyNode } from '../../jsonc/types';
+import { getLocEnd, getLocStart, nodeAtPath } from '../../json';
+import { doesFileExist } from '../../utils/file-utils';
+
+export function isPropertyNode(node: unknown): node is PropertyNode {
+  return typeof node === 'object' && node !== null;
+}
+
+function isNestedBlock(currentPath: string[]): boolean {
+  return currentPath.filter((segment) => segment === 'blocks').length > 1;
+}
+
+function reportWarning(
+  message: string,
+  offset: number,
+  astNode: JSONNode,
+  context: Context<SourceCodeType.JSON>,
+) {
+  context.report({
+    message,
+    startIndex: offset + getLocStart(astNode),
+    endIndex: offset + getLocEnd(astNode),
+  });
+}
+
+async function validateBlockFileExistence(
+  blockType: string,
+  context: Context<SourceCodeType.JSON>,
+): Promise<boolean> {
+  if (blockType === '@theme' || blockType === '@app') {
+    return true;
+  }
+  const blockPath = `blocks/${blockType}.liquid`;
+  return await doesFileExist(context, blockPath);
+}
+
+async function getThemeBlocks(
+  sectionType: string,
+  currentPath: string[],
+  context: Context<SourceCodeType.JSON>,
+): Promise<string[]> {
+  const themeBlocks: string[] = [];
+  if (!sectionType) return themeBlocks;
+
+  const schema = isNestedBlock(currentPath)
+    ? await context.getBlockSchema?.(sectionType)
+    : await context.getSectionSchema?.(sectionType);
+  if (!schema || schema instanceof Error) return themeBlocks;
+
+  const { validSchema } = schema;
+  if (!validSchema || validSchema instanceof Error) return themeBlocks;
+
+  if (Array.isArray(validSchema.blocks)) {
+    validSchema.blocks.forEach((block) => {
+      if (!('name' in block) && block.type !== '@app') {
+        themeBlocks.push(block.type);
+      }
+    });
+  }
+  return themeBlocks;
+}
+
+async function validateBlock(
+  blockType: string,
+  blockStatic: boolean,
+  blockPath: JSONNode,
+  ancestorType: string,
+  currentPath: string[],
+  offset: number,
+  context: Context<SourceCodeType.JSON>,
+) {
+  const themeBlocks = await getThemeBlocks(ancestorType, currentPath, context);
+  if (themeBlocks.length === 0) return;
+
+  const exists = await validateBlockFileExistence(blockType, context);
+  if (!exists) {
+    reportWarning(
+      `Theme block 'blocks/${blockType}.liquid' does not exist.`,
+      offset,
+      blockPath,
+      context,
+    );
+  } else if (blockStatic) {
+    // Static blocks are not required to be in the schema blocks array
+    return;
+  } else {
+    const isPrivateBlock = blockType.startsWith('_');
+    const schemaIncludesAtTheme = themeBlocks.includes('@theme');
+    const schemaIncludesBlockType = themeBlocks.includes(blockType);
+
+    if (
+      !isPrivateBlock ? schemaIncludesBlockType || schemaIncludesAtTheme : schemaIncludesBlockType
+    ) {
+      return;
+    } else {
+      const location = isNestedBlock(currentPath) ? 'blocks' : 'sections';
+      reportWarning(
+        `Block type '${blockType}' is not allowed in '${location}/${ancestorType}.liquid'.`,
+        offset,
+        blockPath,
+        context,
+      );
+    }
+  }
+}
+
+export async function getAllBlocks(
+  ast: JSONNode,
+  offset: number,
+  ancestorType: string,
+  blocks: PropertyNode,
+  currentPath: string[],
+  context: Context<SourceCodeType.JSON>,
+): Promise<void> {
+  await Promise.all(
+    Object.entries(blocks).map(async ([blockKey, block]) => {
+      if (block.type) {
+        const typePath = currentPath.concat(blockKey, 'type');
+        const blockPath = nodeAtPath(ast, typePath)! as JSONNode;
+
+        if (blockPath) {
+          await validateBlock(
+            block.type,
+            block.static,
+            blockPath,
+            ancestorType,
+            currentPath,
+            offset,
+            context,
+          );
+        }
+      }
+
+      if ('blocks' in block) {
+        await getAllBlocks(
+          ast,
+          offset,
+          block.type,
+          block.blocks,
+          currentPath.concat(blockKey, 'blocks'),
+          context,
+        );
+      }
+    }),
+  );
+}

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

@@ -0,0 +1,64 @@
+import { expect, describe, it } from 'vitest';
+import { JSONSyntaxError } from './index';
+import { highlightedOffenses, runJSONCheck } from '../../test';
+
+describe('Module: JSONSyntaxError', () => {
+  it('should report an error for invalid JSON (0)', async () => {
+    const invalidJson = `{
+      "key1": "value1",
+      "key2": "value2",,
+    }`;
+
+    const offenses = await runJSONCheck(JSONSyntaxError, invalidJson, 'file.json');
+    expect(offenses).to.have.length(2);
+    expect(offenses[0].message).to.equal('Property name expected');
+    expect(offenses[1].message).to.equal('Expecting a value');
+
+    const highlights = highlightedOffenses({ 'file.json': invalidJson }, offenses);
+    expect(highlights).to.have.length(2);
+    expect(highlights[0]).to.equal(',');
+    expect(highlights[1]).to.equal(',');
+  });
+
+  it('should report an error for invalid JSON (1)', async () => {
+    const invalidJson = `{
+      "key1": "value1",
+      "key2": "value2"
+    `;
+
+    const offenses = await runJSONCheck(JSONSyntaxError, invalidJson, 'file.json');
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal('Expecting a closing brace (})');
+
+    const highlights = highlightedOffenses({ 'file.json': invalidJson }, offenses);
+    expect(highlights).to.have.length(1);
+    expect(highlights[0]).to.equal('');
+  });
+
+  it('should report an error for invalid JSON (2)', async () => {
+    const invalidJson = `{
+      'key1': "value1",
+      "key2": "value2"
+    }`;
+
+    const offenses = await runJSONCheck(JSONSyntaxError, invalidJson, 'file.json');
+    expect(offenses).to.have.length(3);
+    expect(offenses[0].message).to.equal('Invalid symbol');
+    expect(offenses[1].message).to.equal('Property name expected');
+    expect(offenses[2].message).to.equal('Expecting a value');
+
+    const highlights = highlightedOffenses({ 'file.json': invalidJson }, offenses);
+    expect(highlights).to.have.length(3);
+    expect(highlights[0]).to.equal("'key1'");
+  });
+
+  it('should not report any errors for valid JSON', async () => {
+    const validJson = `{
+      "key1": "value1",
+      "key2": "value2"
+    }`;
+
+    const offenses = await runJSONCheck(JSONSyntaxError, validJson);
+    expect(offenses).to.be.empty;
+  });
+});