@platformos/platformos-check-common 0.0.7 → 0.0.8

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

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

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

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

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