@platformos/platformos-check-common 0.0.2

package/src/checks/valid-schema/index.spec.ts

@@ -0,0 +1,174 @@
+import lodashSet from 'lodash/set';
+import { describe, expect, it } from 'vitest';
+import { runLiquidCheck, highlightedOffenses } from '../../test';
+import { ValidSchema } from './index';
+import { Dependencies } from '../../types';
+
+const DEFAULT_FILE_NAME = 'sections/file.liquid';
+const VALID_SECTION_SCHEMA = {
+  shouldBeString: 't:sections.main-addresses.name',
+  shouldBeNumber: 10,
+  shouldBeIntegerLessThan51: 50,
+};
+
+// Deep copy valid data
+const INVALID_SECTION_SCHEMA = JSON.parse(JSON.stringify(VALID_SECTION_SCHEMA));
+
+lodashSet(INVALID_SECTION_SCHEMA, 'shouldBeString', 420);
+lodashSet(INVALID_SECTION_SCHEMA, 'shouldBeNumber', true);
+lodashSet(INVALID_SECTION_SCHEMA, 'shouldBeIntegerLessThan51', 51);
+
+const MockSectionSchemaJsonSchema = {
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  type: 'object',
+  properties: {
+    shouldBeString: {
+      type: 'string',
+    },
+    shouldBeNumber: {
+      type: 'number',
+    },
+    shouldBeIntegerLessThan51: {
+      type: 'integer',
+      description: 'The number of times a section can be added to a template or section group.',
+      maximum: 50,
+    },
+  },
+};
+
+const buildMockDeps = (): Partial<Dependencies> => ({
+  jsonValidationSet: {
+    schemas: async () => [
+      {
+        uri: 'https://shopify.dev/some-schema.json',
+        schema: JSON.stringify(MockSectionSchemaJsonSchema),
+        fileMatch: ['**/sections/*.liquid'],
+      },
+    ],
+  },
+});
+
+describe('ValidSchema', () => {
+  it('should report a syntax error when the schema json is malformed', async () => {
+    const sourceCode = `
+    {% schema %}
+    {
+
+    {% endschema %}
+    `;
+
+    const offenses = await runLiquidCheck(
+      ValidSchema,
+      sourceCode,
+      DEFAULT_FILE_NAME,
+      buildMockDeps(),
+    );
+    const highlights = highlightedOffenses({ [DEFAULT_FILE_NAME]: sourceCode }, offenses);
+    expect(highlights).to.have.length(1);
+    expect(highlights[0].trim()).to.equal('{');
+
+    expect(offenses).to.have.length(1);
+    expect(offenses).to.containOffense({
+      check: ValidSchema.meta.code,
+      message: expect.stringContaining('Expected comma or closing brace'),
+      uri: `file:///${DEFAULT_FILE_NAME}`,
+    });
+  });
+
+  it('should not report a syntax error when the schema json has a trailing comma', async () => {
+    const sourceCode = `
+    {% schema %}
+    {
+      "comma": "not trailing",
+    }
+    {% endschema %}
+    `;
+
+    const offenses = await runLiquidCheck(
+      ValidSchema,
+      sourceCode,
+      DEFAULT_FILE_NAME,
+      buildMockDeps(),
+    );
+
+    expect(offenses).to.have.length(0);
+  });
+
+  it('should complain appropriately when a section schema contains errors', async () => {
+    const sourceCode = `
+    {% schema %}
+    ${JSON.stringify(INVALID_SECTION_SCHEMA, null, 2)}
+    {% endschema %}
+    `;
+
+    const offenses = await runLiquidCheck(
+      ValidSchema,
+      sourceCode,
+      DEFAULT_FILE_NAME,
+      buildMockDeps(),
+    );
+
+    expect(offenses).to.have.length(3);
+    expect(offenses).to.containOffense({
+      check: ValidSchema.meta.code,
+      message: 'Incorrect type. Expected "string".',
+      uri: `file:///${DEFAULT_FILE_NAME}`,
+    });
+    expect(offenses).to.containOffense({
+      check: ValidSchema.meta.code,
+      message: 'Incorrect type. Expected "number".',
+      uri: `file:///${DEFAULT_FILE_NAME}`,
+    });
+    expect(offenses).to.containOffense({
+      check: ValidSchema.meta.code,
+      message: 'Value is above the maximum of 50.',
+      uri: `file:///${DEFAULT_FILE_NAME}`,
+    });
+  });
+
+  it('should not complain when there is no JSON schema associated with the file', async () => {
+    const sourceCode = `
+    {% schema %}
+    ${JSON.stringify(INVALID_SECTION_SCHEMA, null, 2)}
+    {% endschema %}
+    `;
+
+    const offenses = await runLiquidCheck(
+      ValidSchema,
+      sourceCode,
+      '/blocks/file.liquid',
+      buildMockDeps(),
+    );
+
+    expect(offenses).to.have.length(0);
+  });
+
+  it('should not complain when a section schema is valid', async () => {
+    const sourceCode = `
+    {% schema %}
+    ${JSON.stringify(VALID_SECTION_SCHEMA, null, 2)}
+    {% endschema %}
+    `;
+
+    const offenses = await runLiquidCheck(
+      ValidSchema,
+      sourceCode,
+      DEFAULT_FILE_NAME,
+      buildMockDeps(),
+    );
+
+    expect(offenses).to.have.length(0);
+  });
+
+  it('should not complain when a schema is invalid outside of sections', async () => {
+    const sourceCode = `
+    {% schema %}
+    ${JSON.stringify(INVALID_SECTION_SCHEMA, null, 2)}
+    {% endschema %}
+    `;
+
+    const offenses = await runLiquidCheck(ValidSchema, sourceCode);
+
+    expect(offenses).to.have.length(0);
+  });
+});

package/src/checks/valid-schema/index.ts

@@ -0,0 +1,41 @@
+import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
+
+export const ValidSchema: LiquidCheckDefinition = {
+  meta: {
+    code: 'ValidSchema',
+    name: 'Prevent invalid JSON in {% schema %} tags',
+    docs: {
+      description: 'This check is aimed at eliminating JSON errors in schema tags.',
+      recommended: true,
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/valid-schema',
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.ERROR,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    return {
+      async LiquidRawTag(node) {
+        if (node.name !== 'schema' || node.body.kind !== 'json' || !context.validateJSON) {
+          return;
+        }
+        const jsonString = node.source.slice(
+          node.blockStartPosition.end,
+          node.blockEndPosition.start,
+        );
+        const problems = await context.validateJSON(context.file.uri, jsonString);
+        if (!problems) return;
+
+        for (const problem of problems) {
+          context.report({
+            message: problem.message,
+            startIndex: node.blockStartPosition.end + problem.startIndex,
+            endIndex: node.blockStartPosition.end + problem.endIndex,
+          });
+        }
+      },
+    };
+  },
+};

package/src/checks/valid-schema-name/index.spec.ts

@@ -0,0 +1,112 @@
+import { expect, describe, it } from 'vitest';
+import { highlightedOffenses, runLiquidCheck, check } from '../../test';
+import { ValidSchemaName } from './index';
+import { ThemeSchemaType } from '../..';
+
+const DEFAULT_FILE_NAME = 'sections/file.liquid';
+
+describe('Module: ValidSchemaName', () => {
+  // We have a different check for that
+  it('reports no offense when the schema is invalid', async () => {
+    const sourceCode = `
+      {% schema %}
+        {
+          "name": 10
+        }
+      {% endschema %}
+    `;
+    const offenses = await runLiquidCheck(ValidSchemaName, sourceCode, DEFAULT_FILE_NAME, {
+      getSectionSchema: async () => ({
+        ast: new Error('Invalid schema'),
+        parsed: new Error('Invalid schema'),
+        validSchema: new Error('Invalid schema'),
+        name: 'file',
+        type: ThemeSchemaType.Section,
+        offset: 0,
+        value: '',
+        staticBlockDefs: [],
+      }),
+    });
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('reports offense with schema name over 25 characters long', async () => {
+    const sourceCode = `
+      {% schema %}
+        {
+          "name": "test-schema-name-that-is-too-long"
+        }
+      {% endschema %}
+    `;
+
+    const offenses = await runLiquidCheck(ValidSchemaName, sourceCode, DEFAULT_FILE_NAME);
+    expect(offenses).toHaveLength(1);
+    expect(offenses[0].message).toEqual(
+      "Schema name 'test-schema-name-that-is-too-long' is too long (max 25 characters)",
+    );
+
+    const highlights = highlightedOffenses({ [DEFAULT_FILE_NAME]: sourceCode }, offenses);
+    expect(highlights).to.have.length(1);
+    expect(highlights[0]).toBe('"test-schema-name-that-is-too-long"');
+  });
+
+  it('reports no offenses with schema name translation that exists and is not over 25 chars long', async () => {
+    const offenses = await check(
+      {
+        'locales/en.default.schema.json':
+          '{ "default": { "my_translation_key": "My translation is good."}}',
+        'code.liquid': `
+          {% schema %}
+            {
+              "name": "t:default.my_translation_key"
+            }
+          {% endschema %}`,
+      },
+      [ValidSchemaName],
+    );
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('reports an offense with schema name translation is missing', async () => {
+    const offenses = await check(
+      {
+        'locales/en.default.schema.json': '{ "another_translation_key": "Another translation"}',
+        'sections/file.liquid': `
+          {% schema %}
+            {
+              "name": "t:my_translation_key"
+            }
+          {% endschema %}`,
+      },
+      [ValidSchemaName],
+    );
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses[0].message).toEqual(
+      "'t:my_translation_key' does not have a matching entry in 'locales/en.default.schema.json'",
+    );
+  });
+
+  it('reports an offense with schema name translation that exists and is over 25 chars long', async () => {
+    const offenses = await check(
+      {
+        'locales/en.default.schema.json':
+          '{ "my_translation_key": "My translation is tooooooooo long."}',
+        'blocks/code.liquid': `
+          {% schema %}
+            {
+              "name": "t:my_translation_key"
+            }
+          {% endschema %}`,
+      },
+      [ValidSchemaName],
+    );
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses[0].message).toEqual(
+      "Schema name 'My translation is tooooooooo long.' from 'locales/en.default.schema.json' is too long (max 25 characters)",
+    );
+  });
+});

package/src/checks/valid-schema-name/index.ts

@@ -0,0 +1,75 @@
+import { getLocEnd, getLocStart, nodeAtPath } from '../../json';
+import { getSchema } from '../../to-schema';
+import { LiquidCheckDefinition, LiteralNode, Severity, SourceCodeType } from '../../types';
+import { deepGet } from '../../utils';
+
+const MAX_SCHEMA_NAME_LENGTH = 25;
+
+export const ValidSchemaName: LiquidCheckDefinition = {
+  meta: {
+    code: 'ValidSchemaName',
+    name: 'Enforce valid schema name',
+    docs: {
+      description: 'This check is aimed at ensuring a valid schema name.',
+      recommended: true,
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/valid-schema-name',
+    },
+    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 name = validSchema.name;
+        if (!name) return;
+
+        // We can make this type assertion because we know the schema is valid
+        const nameNode = nodeAtPath(ast, ['name'])! as LiteralNode;
+        const startIndex = offset + getLocStart(nameNode);
+        const endIndex = offset + getLocEnd(nameNode);
+
+        if (name.startsWith('t:')) {
+          const defaultLocale = await context.getDefaultLocale();
+          const key = name.replace('t:', '');
+          const defaultTranslations = await context.getDefaultSchemaTranslations();
+          const translation = deepGet(defaultTranslations, key.split('.'));
+
+          if (translation === undefined) {
+            context.report({
+              message: `'${name}' does not have a matching entry in 'locales/${defaultLocale}.default.schema.json'`,
+              startIndex,
+              endIndex,
+            });
+          }
+
+          if (translation !== undefined && translation.length > MAX_SCHEMA_NAME_LENGTH) {
+            context.report({
+              message: `Schema name '${translation}' from 'locales/${defaultLocale}.default.schema.json' is too long (max 25 characters)`,
+              startIndex,
+              endIndex,
+            });
+          }
+        } else if (name.length > MAX_SCHEMA_NAME_LENGTH) {
+          context.report({
+            message: `Schema name '${name}' is too long (max 25 characters)`,
+            startIndex,
+            endIndex,
+          });
+        }
+      },
+    };
+  },
+};