@platformos/platformos-check-common 0.0.7 → 0.0.8

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

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

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

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