@platformos/platformos-check-common 0.0.2

package/src/checks/valid-settings-key/index.spec.ts

@@ -0,0 +1,321 @@
+import { expect, describe, it } from 'vitest';
+import { check } from '../../test';
+import { ValidSettingsKey } from './index';
+
+describe('Module: ValidSettingsKey', () => {
+  const schemaTemplate = {
+    name: 'Example',
+    settings: [
+      {
+        id: 'existent-setting',
+        type: 'text',
+        label: 'Example Text Setting',
+      },
+    ],
+  };
+
+  describe('default settings', () => {
+    it('does not report an error when default setting exists', async () => {
+      const theme = {
+        'sections/example.liquid': toLiquidFile({
+          ...schemaTemplate,
+          default: {
+            settings: {
+              'existent-setting': 'value',
+            },
+          },
+        }),
+      };
+
+      const offenses = await check(theme, [ValidSettingsKey]);
+      expect(offenses).to.have.length(0);
+    });
+
+    it('reports an error when default setting does not exist', async () => {
+      const theme = {
+        'sections/example.liquid': toLiquidFile({
+          ...schemaTemplate,
+          default: {
+            settings: {
+              'non-existent-setting': 'value',
+            },
+          },
+        }),
+      };
+
+      const offenses = await check(theme, [ValidSettingsKey]);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal(
+        `Setting 'non-existent-setting' does not exist in schema.`,
+      );
+    });
+
+    it('does not report an error when missing default settings is referenced from a block schema', async () => {
+      const theme = {
+        'blocks/example.liquid': toLiquidFile({
+          ...schemaTemplate,
+          default: {
+            settings: {
+              'non-existent-setting': 'value',
+            },
+          },
+        }),
+      };
+
+      const offenses = await check(theme, [ValidSettingsKey]);
+      expect(offenses).to.have.length(0);
+    });
+  });
+
+  describe('presets settings', () => {
+    it('does not report an error when presets setting exists', async () => {
+      const theme = {
+        'sections/example.liquid': toLiquidFile({
+          ...schemaTemplate,
+          presets: [
+            {
+              settings: {
+                'existent-setting': 'value',
+              },
+            },
+          ],
+        }),
+      };
+
+      const offenses = await check(theme, [ValidSettingsKey]);
+      expect(offenses).to.have.length(0);
+    });
+
+    it('reports an error when presets setting does not exist', async () => {
+      const theme = {
+        'sections/example.liquid': toLiquidFile({
+          ...schemaTemplate,
+          presets: [
+            {
+              settings: {
+                'non-existent-setting-1': 'value',
+              },
+            },
+            {
+              settings: {
+                'non-existent-setting-2': 'value',
+              },
+            },
+          ],
+        }),
+      };
+
+      const offenses = await check(theme, [ValidSettingsKey]);
+      expect(offenses).to.have.length(2);
+      expect(offenses[0].message).to.equal(
+        `Setting 'non-existent-setting-1' does not exist in schema.`,
+      );
+      expect(offenses[1].message).to.equal(
+        `Setting 'non-existent-setting-2' does not exist in schema.`,
+      );
+    });
+  });
+
+  const tests = [
+    {
+      label: 'default',
+      blockTemplate: (blocks: any[]) => {
+        return {
+          default: {
+            blocks,
+          },
+        };
+      },
+    },
+    {
+      label: 'presets',
+      blockTemplate: (blocks: any[]) => {
+        return {
+          presets: [
+            {
+              blocks,
+            },
+          ],
+        };
+      },
+    },
+  ];
+
+  tests.forEach(({ label, blockTemplate }) => {
+    describe(`${label} block settings`, () => {
+      describe('referenced blocks', () => {
+        const referencedBlock = {
+          'blocks/referenced.liquid': toLiquidFile(schemaTemplate),
+        };
+
+        it(`does not report an error when ${label} block setting exists in referenced file`, async () => {
+          const fileToTest = {
+            'sections/example.liquid': toLiquidFile({
+              ...schemaTemplate,
+              ...blockTemplate([
+                {
+                  type: 'referenced',
+                  settings: {
+                    'existent-setting': 'value',
+                  },
+                },
+              ]),
+            }),
+          };
+
+          const offenses = await check(
+            {
+              ...referencedBlock,
+              ...fileToTest,
+            },
+            [ValidSettingsKey],
+          );
+          expect(offenses).to.have.length(0);
+        });
+
+        it('does not report an error when referenced file does not exist', async () => {
+          const fileToTest = {
+            'sections/example.liquid': toLiquidFile({
+              ...schemaTemplate,
+              ...blockTemplate([
+                {
+                  type: 'non-existent-file',
+                  settings: {
+                    'non-existent-setting': 'value',
+                  },
+                },
+              ]),
+            }),
+          };
+
+          const offenses = await check(
+            {
+              ...referencedBlock,
+              ...fileToTest,
+            },
+            [ValidSettingsKey],
+          );
+          expect(offenses).to.have.length(0);
+        });
+
+        it(`reports an error when ${label} block setting does not exist in referenced file`, async () => {
+          const fileToTest = {
+            'sections/example.liquid': toLiquidFile({
+              ...schemaTemplate,
+              ...blockTemplate([
+                {
+                  type: 'referenced',
+                  settings: {
+                    'non-existent-setting': 'value',
+                  },
+                },
+              ]),
+            }),
+          };
+
+          const offenses = await check(
+            {
+              ...referencedBlock,
+              ...fileToTest,
+            },
+            [ValidSettingsKey],
+          );
+          expect(offenses).to.have.length(1);
+          expect(offenses[0].message).to.equal(
+            `Setting 'non-existent-setting' does not exist in 'blocks/referenced.liquid'.`,
+          );
+        });
+      });
+
+      describe('local blocks', () => {
+        const localBlocksTemplate = {
+          blocks: [
+            {
+              type: 'local-block',
+              name: 'Local block',
+              settings: [
+                {
+                  id: 'local-setting',
+                  type: 'text',
+                  label: 'Local Setting',
+                },
+              ],
+            },
+          ],
+        };
+
+        it(`reports an error when ${label} block setting does not exist in existing local block`, async () => {
+          const fileToTest = {
+            'sections/example.liquid': toLiquidFile({
+              ...localBlocksTemplate,
+              ...blockTemplate([
+                {
+                  type: 'local-block',
+                  settings: {
+                    'non-existent-setting-1': 'value',
+                    'non-existent-setting-2': 'value',
+                  },
+                },
+              ]),
+            }),
+          };
+
+          const offenses = await check(fileToTest, [ValidSettingsKey]);
+          expect(offenses).to.have.length(2);
+          expect(offenses[0].message).to.equal(
+            `Setting 'non-existent-setting-1' does not exist in schema.`,
+          );
+          expect(offenses[1].message).to.equal(
+            `Setting 'non-existent-setting-2' does not exist in schema.`,
+          );
+        });
+
+        it(`does not report an error when ${label} block setting does not exist in non-existent local block`, async () => {
+          const fileToTest = {
+            'sections/example.liquid': toLiquidFile({
+              ...localBlocksTemplate,
+              ...blockTemplate([
+                {
+                  type: 'non-existent-local-block',
+                  settings: {
+                    'non-existent-setting': 'value',
+                  },
+                },
+              ]),
+            }),
+          };
+
+          const offenses = await check(fileToTest, [ValidSettingsKey]);
+          expect(offenses).to.have.length(0);
+        });
+
+        it(`does not report an error when ${label} block setting exists in local block`, async () => {
+          const fileToTest = {
+            'sections/example.liquid': toLiquidFile({
+              ...localBlocksTemplate,
+              ...blockTemplate([
+                {
+                  type: 'local-block',
+                  settings: {
+                    'local-setting': 'value',
+                  },
+                },
+              ]),
+            }),
+          };
+
+          const offenses = await check(fileToTest, [ValidSettingsKey]);
+          expect(offenses).to.have.length(0);
+        });
+      });
+    });
+  });
+});
+
+function toLiquidFile(content: any) {
+  return `
+    {% schema %}
+      ${JSON.stringify(content)}
+    {% endschema %}
+  `;
+}

package/src/checks/valid-settings-key/index.ts

@@ -0,0 +1,144 @@
+import {
+  LiquidCheckDefinition,
+  Severity,
+  SourceCodeType,
+  Preset,
+  Section,
+  ThemeBlock,
+  JSONNode,
+  Setting,
+} from '../../types';
+import { nodeAtPath } from '../../json';
+import { getSchema, isSectionSchema } from '../../to-schema';
+import { BlockDefNodeWithPath, getBlocks, reportWarning } from '../../utils';
+
+export const ValidSettingsKey: LiquidCheckDefinition = {
+  meta: {
+    code: 'ValidSettingsKey',
+    name: 'Validate settings key in presets',
+    docs: {
+      description:
+        'Ensures settings key only references valid settings defined in its respective schema',
+      recommended: true,
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/valid-settings-key',
+    },
+    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;
+
+        const { rootLevelLocalBlocks, presetLevelBlocks } = getBlocks(validSchema);
+
+        // Check if presets settings match schema-level settings
+        if (validSchema.presets) {
+          for (let i = 0; i < validSchema.presets.length; i++) {
+            const settingsNode = nodeAtPath(ast, ['presets', i, 'settings']);
+
+            validateSettingsKey(context, offset, settingsNode, validSchema.settings);
+          }
+        }
+
+        if (isSectionSchema(schema) && 'default' in validSchema && validSchema.default) {
+          // Check if default settings match schema-level settings
+          const settingsNode = nodeAtPath(ast, ['default', 'settings']);
+
+          validateSettingsKey(context, offset, settingsNode, validSchema.settings);
+
+          // Check if default block settings match the settings defined in the block file's schema
+          await Promise.all(
+            validSchema.default.blocks?.map((block, i) => {
+              const settingsNode = nodeAtPath(ast, ['default', 'blocks', i, 'settings']);
+              return validateReferencedBlock(
+                context,
+                offset,
+                settingsNode,
+                rootLevelLocalBlocks,
+                block,
+              );
+            }) || [],
+          );
+        }
+
+        // Check if preset block settings match the settings defined in the block file's schema
+        await Promise.all(
+          Object.entries(presetLevelBlocks).flatMap(([_depthStr, blocks]) =>
+            blocks.map(({ node: blockNode, path }) => {
+              const settingsNode = nodeAtPath(ast, path.slice(0, -1).concat('settings'));
+
+              return validateReferencedBlock(
+                context,
+                offset,
+                settingsNode,
+                rootLevelLocalBlocks,
+                blockNode,
+              );
+            }),
+          ),
+        );
+      },
+    };
+  },
+};
+
+async function validateReferencedBlock(
+  context: any,
+  offset: number,
+  settingsNode: JSONNode | undefined,
+  localBlocks: BlockDefNodeWithPath[],
+  referencedBlock: Preset.Block | Section.Block | ThemeBlock.Block,
+) {
+  if (localBlocks.length > 0) {
+    const localBlock = localBlocks.find(
+      (localBlock) => localBlock.node.type === referencedBlock.type,
+    );
+
+    if (!localBlock) return;
+
+    const localBlockNode = localBlock.node as Section.LocalBlock;
+
+    validateSettingsKey(context, offset, settingsNode, localBlockNode.settings);
+  } else {
+    const blockSchema = await context.getBlockSchema?.(referencedBlock.type);
+    const { validSchema: validBlockSchema } = blockSchema ?? {};
+    if (!validBlockSchema || validBlockSchema instanceof Error) return;
+
+    validateSettingsKey(context, offset, settingsNode, validBlockSchema.settings, referencedBlock);
+  }
+}
+
+function validateSettingsKey(
+  context: any,
+  offset: number,
+  settingsNode: JSONNode | undefined,
+  validSettings: Setting.Any[] | undefined,
+  blockNode?: Section.Block | ThemeBlock.Block | Preset.Block,
+) {
+  if (!settingsNode || settingsNode.type !== 'Object') return;
+
+  for (const setting of settingsNode.children) {
+    const settingExists = validSettings?.find(
+      (validSetting) => validSetting?.id === setting.key.value,
+    );
+
+    if (!settingExists) {
+      const errorMessage = blockNode
+        ? `Setting '${setting.key.value}' does not exist in 'blocks/${blockNode.type}.liquid'.`
+        : `Setting '${setting.key.value}' does not exist in schema.`;
+
+      reportWarning(errorMessage, offset, setting.key, context);
+    }
+  }
+}

package/src/checks/valid-static-block-type/index.spec.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import { check, MockTheme } from '../../test';
+import { ValidStaticBlockType } from '.';
+
+describe('Module: ValidStaticBlockType', () => {
+  const genericThemeBlock = {
+    'blocks/valid.liquid': 'Hello world!',
+  };
+
+  const validTypeBlock = {
+    'blocks/file.liquid': '{% content_for "block", type: "valid", id: "static-block" %}',
+  };
+
+  const invalidTypeBlock = {
+    'blocks/file.liquid': '{% content_for "block", type: "invalid", id: "static-block" %}',
+  };
+
+  const validExtensionFiles: MockTheme = {
+    ...genericThemeBlock,
+    ...validTypeBlock,
+  };
+
+  const invalidExtensionFiles: MockTheme = {
+    ...genericThemeBlock,
+    ...invalidTypeBlock,
+  };
+
+  it('should not report any offenses if type is valid', async () => {
+    const offenses = await check(validExtensionFiles);
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should report an offense if type is invalid', async () => {
+    const offenses = await check(invalidExtensionFiles);
+    expect(offenses).toHaveLength(1);
+    expect(offenses[0].message).to.equal("'blocks/invalid.liquid' does not exist");
+  });
+});

package/src/checks/valid-static-block-type/index.ts

@@ -0,0 +1,58 @@
+import { NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
+import { doesFileExist } from '../../utils/file-utils';
+import { isContentForBlock } from '../../utils/markup';
+
+export const ValidStaticBlockType: LiquidCheckDefinition = {
+  meta: {
+    code: 'ValidStaticBlockType',
+    name: 'Prevent use of type that is not valid for static blocks',
+    docs: {
+      description:
+        'This check is aimed at preventing the use of an invalid type for blocks rendered statically.',
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/valid-static-block-type',
+      recommended: true,
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.ERROR,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    return {
+      async LiquidTag(node) {
+        if (node.name !== 'content_for') {
+          return;
+        }
+
+        if (!isContentForBlock(node.markup)) {
+          return;
+        }
+
+        const typeArg = node.markup.args.find((arg) => arg.name === 'type');
+        if (!typeArg) {
+          return; // covered by VariableContentForArguments
+        }
+
+        const typeArgValueNode = typeArg.value;
+        if (typeArgValueNode.type !== NodeTypes.String) {
+          return; // covered by VariableContentForArguments
+        }
+
+        const blockName = typeArgValueNode.value;
+        const relativePath = `blocks/${blockName}.liquid`;
+        const fileExists = await doesFileExist(context, relativePath);
+
+        if (!fileExists) {
+          context.report({
+            message: `'blocks/${blockName}.liquid' does not exist`,
+            startIndex: typeArgValueNode.position.start,
+            endIndex: typeArgValueNode.position.end,
+            suggest: [],
+          });
+        }
+      },
+    };
+  },
+};