@platformos/platformos-check-common 0.0.7 → 0.0.8

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

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

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

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

@@ -1,58 +0,0 @@
-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: [],
-          });
-        }
-      },
-    };
-  },
-};