@platformos/platformos-check-common 0.0.6 → 0.0.8

package/src/yaml/parse.ts

@@ -0,0 +1,111 @@
+import { isMap, isScalar, isSeq, isPair, parseDocument } from 'yaml';
+import type { Pair, Scalar, YAMLMap, YAMLSeq } from 'yaml';
+import type {
+  ArrayNode,
+  IdentifierNode,
+  JSONNode,
+  LiteralNode,
+  Location,
+  ObjectNode,
+  PropertyNode,
+  ValueNode,
+} from '../jsonc/types';
+
+export class YAMLConvertError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'YAMLConvertError';
+  }
+}
+
+function loc(start: number, end: number): Location {
+  return { start: { offset: start }, end: { offset: end } };
+}
+
+function getRange(node: any): [number, number] {
+  if (node && node.range && Array.isArray(node.range)) {
+    const start = node.range[0] ?? 0;
+    const end = node.range[1] ?? 0;
+    return [start, end];
+  }
+  return [0, 0];
+}
+
+export function toYAMLNode(source: string): JSONNode {
+  const doc = parseDocument(source);
+
+  if (doc.errors.length > 0) {
+    throw new YAMLConvertError(doc.errors[0].message);
+  }
+
+  if (doc.contents === null || doc.contents === undefined) {
+    return { type: 'Object', children: [], loc: loc(0, 0) } as ObjectNode;
+  }
+
+  return convertNode(doc.contents as any, source) as JSONNode;
+}
+
+function convertNode(node: any, source: string): JSONNode {
+  if (isMap(node)) return convertMap(node, source);
+  if (isSeq(node)) return convertSeq(node, source);
+  if (isScalar(node)) return convertScalar(node);
+  return { type: 'Literal', value: null, raw: 'null', loc: loc(0, 0) } as LiteralNode;
+}
+
+function convertMap(node: YAMLMap, source: string): ObjectNode {
+  const [start, end] = getRange(node);
+  return {
+    type: 'Object',
+    children: node.items.map((pair) => convertPair(pair as Pair<any, any>, source)),
+    loc: loc(start, end),
+  };
+}
+
+function convertPair(pair: Pair<any, any>, source: string): PropertyNode {
+  const key = pair.key as Scalar;
+  const value = pair.value;
+
+  const [keyStart, keyEnd] = getRange(key);
+  const [, valueEnd] = value ? getRange(value) : [keyEnd, keyEnd];
+  const pairEnd = valueEnd > keyEnd ? valueEnd : keyEnd;
+
+  return {
+    type: 'Property',
+    key: convertIdentifier(key),
+    value: value
+      ? (convertNode(value, source) as ValueNode)
+      : ({ type: 'Literal', value: null, raw: 'null', loc: loc(keyEnd, keyEnd) } as LiteralNode),
+    loc: loc(keyStart, pairEnd),
+  };
+}
+
+function convertIdentifier(node: Scalar): IdentifierNode {
+  const [start, end] = getRange(node);
+  const value = String(node.value ?? '');
+  return {
+    type: 'Identifier',
+    value,
+    raw: JSON.stringify(value),
+    loc: loc(start, end),
+  };
+}
+
+function convertScalar(node: Scalar): LiteralNode {
+  const [start, end] = getRange(node);
+  const value = node.value as string | number | boolean | null;
+  return {
+    type: 'Literal',
+    value,
+    raw: JSON.stringify(value),
+    loc: loc(start, end),
+  };
+}
+
+function convertSeq(node: YAMLSeq, source: string): ArrayNode {
+  const [start, end] = getRange(node);
+  return {
+    type: 'Array',
+    children: node.items.map((item) => convertNode(item, source) as ValueNode),
+    loc: loc(start, end),
+  };
+}

package/src/AugmentedThemeDocset.ts

@@ -1,137 +0,0 @@
-import {
-  Access,
-  FilterEntry,
-  ObjectEntry,
-  TagEntry,
-  ThemeDocset,
-  Translations,
-  ReturnType,
-} from './types';
-import { memo } from './utils';
-
-const toFilterEntry = (name: string): FilterEntry => ({ name });
-
-const expandAliases = (entries: FilterEntry[]): FilterEntry[] => {
-  return entries.flatMap((entry) => {
-    const aliases: string[] = (entry as any).aliases ?? [];
-    return aliases.map((alias) => ({ ...entry, name: alias }));
-  });
-};
-
-const undocumentedFilters = [
-  '_online_store_editor_live_setting',
-  'addresses_url',
-  'app_block_path?',
-  'app_block_path_for',
-  'app_extension_path?',
-  'app_snippet_path?',
-  'cancel_customer_order_link',
-  'debug',
-  'delete_customer_address_link',
-  'dev_shop?',
-  'distance_from',
-  'edit_customer_address_link',
-  'encode_url_component',
-  'excerpt',
-  'format_code',
-  'global_block_type?',
-  'h',
-  'handle_from',
-  'installments_pricing',
-  'link_to_theme',
-  'login_button',
-  'login_url',
-  'logout_url',
-  'pad_spaces',
-  'paragraphize',
-  'recover_password_link',
-  'recover_url',
-  'register_url',
-  'registration_uuid_from',
-  'root_account_url',
-  'sentence',
-  'theme_url',
-  'unit',
-  'weight',
-];
-
-const undocumentedObjectEntryKeys = [
-  'locale',
-  'direction',
-  'skip_to_content_link',
-  'checkout_html_classes',
-  'checkout_stylesheets',
-  'checkout_scripts',
-  'content_for_logo',
-  'breadcrumb',
-  'order_summary_toggle',
-  'content_for_order_summary',
-  'alternative_payment_methods',
-  'content_for_footer',
-  'tracking_code',
-];
-
-const toObjectEntry = (name: string, access?: Access, returnType?: ReturnType[]): ObjectEntry => ({
-  name,
-  ...(access && { access }),
-  ...(returnType && { return_type: returnType }),
-});
-
-const undocumentedObjects = ['customer_address', 'product_variant'];
-const legacyCheckoutEntries: ObjectEntry[] = undocumentedObjectEntryKeys.map((objectKey) =>
-  toObjectEntry(objectKey, { global: false, parents: [], template: [] }, [
-    { type: 'string', name: '' },
-  ]),
-);
-
-const toTagEntry = (name: string): TagEntry => ({ name });
-const undocumentedTags = ['elsif', 'ifchanged', 'when', 'schema'];
-
-export class AugmentedThemeDocset implements ThemeDocset {
-  constructor(private themeDocset: ThemeDocset) {}
-  graphQL = memo(async (): Promise<string | null> => {
-    return await this.themeDocset.graphQL();
-  });
-
-  public isAugmented = true;
-
-  filters = memo(async (): Promise<FilterEntry[]> => {
-    const officialFilters = await this.themeDocset.filters();
-    return [
-      ...officialFilters,
-      ...expandAliases(officialFilters),
-      ...undocumentedFilters.map(toFilterEntry),
-    ];
-  });
-
-  objects = memo(async (): Promise<ObjectEntry[]> => {
-    return [
-      ...(await this.themeDocset.objects()),
-      ...undocumentedObjects.map((obj) => toObjectEntry(obj)),
-      ...legacyCheckoutEntries,
-    ];
-  });
-
-  liquidDrops = memo(async (): Promise<ObjectEntry[]> => {
-    return (await this.themeDocset.objects()).filter((obj) => {
-      if (!obj.access) {
-        return true;
-      }
-
-      if (obj.deprecated) {
-        return false;
-      }
-
-      // objects that are accessible outside Global context
-      return !obj.access.global || (obj.access.global && obj.access.parents.length > 0);
-    });
-  });
-
-  tags = memo(async (): Promise<TagEntry[]> => {
-    return [...(await this.themeDocset.tags()), ...undocumentedTags.map(toTagEntry)];
-  });
-
-  systemTranslations = memo(async (): Promise<Translations> => {
-    return this.themeDocset.systemTranslations();
-  });
-}

package/src/checks/app-block-missing-schema/index.spec.ts

@@ -1,121 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { runLiquidCheck } from '../../test';
-import { AppBlockMissingSchema } from './index';
-
-describe('AppBlockMissingSchema', () => {
-  it('should report an error when schema tag is missing on a theme app extension (blocks only)', async () => {
-    const sourceCode = `
-      <footer class="footer">
-        {% for block in section.blocks %}
-          {% case block.type %}
-            {% when 'link' %}
-              <div class="link" {{ block.shopify_attributes }}>
-                {{ block.settings.linktext | link_to: block.settings.linkurl }}
-              </div>
-
-            {% when 'custom-text' %}
-              <div class="text" {{ block.shopify_attributes }}>
-                {{ block.settings.custom-text-field }}
-              </div>
-          {% endcase %}
-        {% endfor %}
-      </footer>
-    `;
-
-    const offenses = await runLiquidCheck(
-      AppBlockMissingSchema,
-      sourceCode,
-      'blocks/footer.liquid',
-    );
-    expect(offenses).to.have.lengthOf(1);
-  });
-
-  it('should not report an error when schema tag is missing on a snippet in a theme app extension )', async () => {
-    const sourceCode = `
-      <footer class="footer">
-        {% for block in section.blocks %}
-          {% case block.type %}
-            {% when 'link' %}
-              <div class="link" {{ block.shopify_attributes }}>
-                {{ block.settings.linktext | link_to: block.settings.linkurl }}
-              </div>
-
-            {% when 'custom-text' %}
-              <div class="text" {{ block.shopify_attributes }}>
-                {{ block.settings.custom-text-field }}
-              </div>
-          {% endcase %}
-        {% endfor %}
-      </footer>
-    `;
-
-    const offenses = await runLiquidCheck(
-      AppBlockMissingSchema,
-      sourceCode,
-      'app/views/partials/footer.liquid',
-    );
-    expect(offenses).to.have.lengthOf(0);
-  });
-
-  it('should not report when the schema is present on a theme app extension', async () => {
-    const sourceCode = `
-<footer class="footer">
-  {% for block in section.blocks %}
-    {% case block.type %}
-      {% when 'link' %}
-        <div class="link" {{ block.shopify_attributes }}>
-          {{ block.settings.linktext | link_to: block.settings.linkurl }}
-        </div>
-
-      {% when 'custom-text' %}
-        <div class="text" {{ block.shopify_attributes }}>
-          {{ block.settings.custom-text-field }}
-        </div>
-    {% endcase %}
-  {% endfor %}
-</footer>
-
-{% schema %}
-{
-  "name": "Footer",
-  "max_blocks": 8,
-  "blocks": [
-    {
-      "type": "link",
-      "name": "Link",
-      "settings": [
-        {
-          "id": "linkurl",
-          "type": "url",
-          "label": "URL link"
-        },
-        {
-          "id": "linktext",
-          "type": "text",
-          "label": "Link text"
-        }
-      ]
-    },
-    {
-      "type": "custom-text",
-      "name": "Custom Text",
-      "settings": [
-        {
-          "id": "custom-text-field",
-          "type": "textarea",
-          "label": "Text"
-        }
-      ]
-    }
-  ]
-}
-{% endschema %}`;
-
-    const offenses = await runLiquidCheck(
-      AppBlockMissingSchema,
-      sourceCode,
-      'blocks/footer.liquid',
-    );
-    expect(offenses).to.have.lengthOf(0);
-  });
-});

package/src/checks/app-block-missing-schema/index.ts

@@ -1,46 +0,0 @@
-import { ConfigTarget, LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
-
-export const AppBlockMissingSchema: LiquidCheckDefinition = {
-  meta: {
-    code: 'AppBlockMissingSchema',
-    name: 'Missing schema definitions in theme app extensions app blocks should be avoided',
-    docs: {
-      description: 'Report missing schema definitions in theme app extensions app blocks',
-      recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/app-block-missing-schema',
-    },
-    severity: Severity.ERROR,
-    type: SourceCodeType.LiquidHtml,
-    schema: {},
-    targets: [ConfigTarget.ThemeAppExtension],
-  },
-
-  create(context) {
-    let foundSchema = false;
-    const relativePath = context.toRelativePath(context.file.uri);
-
-    /**
-     * Theme app extension blocks are the only types of files that can have a
-     * schema defined in them.
-     */
-    if (!relativePath.startsWith('blocks/')) {
-      return {};
-    }
-
-    return {
-      async LiquidRawTag(node) {
-        if (node.name == 'schema') foundSchema = true;
-      },
-
-      async onCodePathEnd() {
-        if (!foundSchema) {
-          context.report({
-            message: `The schema does not exist`,
-            startIndex: 0,
-            endIndex: 0,
-          });
-        }
-      },
-    };
-  },
-};

package/src/checks/app-block-valid-tags/index.spec.ts

@@ -1,96 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { runLiquidCheck } from '../../test';
-import { ForbiddenTag, AppBlockValidTags } from './index';
-
-const blocksFilePath = 'blocks/app.liquid';
-
-describe('Module: AppBlockValidTags', () => {
-  it('should report an offense when the forbidden tag is used in blocks directory liquid file', async () => {
-    const tags = ['include', 'layout', 'section', 'sections'];
-    for (const tag of tags) {
-      const sourceCode = `
-        {% ${tag} 'test' %}
-        {% schema %}
-        { }
-        {% endschema %}
-      `;
-
-      const offenses = await runLiquidCheck(AppBlockValidTags, sourceCode, blocksFilePath);
-
-      const expectedStart = {
-        index: 9,
-        line: 1,
-        character: 8,
-      };
-      const tagEndOffset = 13;
-      const endOffset = tag.length + tagEndOffset;
-
-      const expectedEnd = {
-        index: expectedStart.index + endOffset,
-        line: expectedStart.line,
-        character: expectedStart.character + endOffset,
-      };
-
-      expect(offenses).to.have.length(1);
-      expect(offenses).to.containOffense({
-        check: AppBlockValidTags.meta.code,
-        message: `Theme app extension blocks cannot contain '${tag}' tags`,
-        uri: 'file:///blocks/app.liquid',
-        severity: 0,
-        start: expectedStart,
-        end: expectedEnd,
-      });
-    }
-  });
-
-  it('should report an offense when the forbidden tag is used with an end tag in blocks directory liquid file', async () => {
-    const tags = ['javascript', 'stylesheet'];
-    for (const tag of tags) {
-      const sourceCode = `
-        {% ${tag} %}
-        {% end${tag} %}
-        {% schema %}
-        { }
-        {% endschema %}
-      `;
-
-      const offenses = await runLiquidCheck(AppBlockValidTags, sourceCode, blocksFilePath);
-
-      const expectedStart = {
-        index: 9,
-        line: 1,
-        character: 8,
-      };
-      const expectedEnd = {
-        index: expectedStart.index + tag.length + 34,
-        line: 2,
-        character: expectedStart.character + tag.length + 9,
-      };
-
-      expect(offenses).to.have.length(1);
-      expect(offenses).to.containOffense({
-        check: AppBlockValidTags.meta.code,
-        message: `Theme app extension blocks cannot contain '${tag}' tags`,
-        uri: 'file:///blocks/app.liquid',
-        severity: 0,
-        start: expectedStart,
-        end: expectedEnd,
-      });
-    }
-  });
-
-  it('should contain specifically the following forbidden tags', async () => {
-    const actualTagValues = Object.values(ForbiddenTag);
-    const expectedTagValues = [
-      'javascript',
-      'stylesheet',
-      'include',
-      'layout',
-      'section',
-      'sections',
-    ];
-
-    expectedTagValues.forEach((tag) => expect(actualTagValues).toContain(tag));
-    expect(actualTagValues.length).toBe(expectedTagValues.length);
-  });
-});

package/src/checks/app-block-valid-tags/index.ts

@@ -1,54 +0,0 @@
-import { LiquidRawTag, LiquidTag } from '@platformos/liquid-html-parser';
-import { ConfigTarget, LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
-
-export enum ForbiddenTag {
-  JavaScript = 'javascript',
-  StyleSheet = 'stylesheet',
-  Include = 'include',
-  Layout = 'layout',
-  Section = 'section',
-  Sections = 'sections',
-}
-
-const isForbiddenTag = (value: string): value is ForbiddenTag => {
-  return Object.values(ForbiddenTag).includes(value as ForbiddenTag);
-};
-
-const buildErrorMessage = (tag: ForbiddenTag) =>
-  `Theme app extension blocks cannot contain '${tag}' tags`;
-
-export const AppBlockValidTags: LiquidCheckDefinition = {
-  meta: {
-    code: 'AppBlockValidTags',
-    name: 'App Block Valid Tags',
-    docs: {
-      description:
-        'Identifies forbidden Liquid tags in theme app extension app block and app embed block code.',
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/app-block-valid-tags',
-      recommended: false,
-    },
-    type: SourceCodeType.LiquidHtml,
-    severity: Severity.ERROR,
-    schema: {},
-    targets: [ConfigTarget.ThemeAppExtension],
-  },
-
-  create(context) {
-    const handleForbiddenTags = async (node: LiquidTag | LiquidRawTag) => {
-      if (isForbiddenTag(node.name)) {
-        // When a forbidden tag is used to define a block section
-        // with an end tag, highlight the whole section
-        const endIndex = node.blockEndPosition ? node.blockEndPosition.end : node.position.end;
-        const startIndex = node.blockStartPosition.start;
-        const message = buildErrorMessage(node.name);
-
-        return context.report({ message, startIndex, endIndex });
-      }
-    };
-
-    return {
-      LiquidRawTag: handleForbiddenTags,
-      LiquidTag: handleForbiddenTags,
-    };
-  },
-};

package/src/checks/asset-preload/index.spec.ts

@@ -1,78 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { runLiquidCheck, highlightedOffenses } from '../../test';
-import { AssetPreload } from './index';
-
-describe('Module: AssetPreload', () => {
-  it('no offense with link element', async () => {
-    const sourceCode = `
-      <link href="a.css" rel="stylesheet">
-      <link href="b.com" rel="preconnect">
-    `;
-
-    const offenses = await runLiquidCheck(AssetPreload, sourceCode);
-    expect(offenses).to.have.lengthOf(0);
-  });
-
-  it('reports stylesheet preloading', async () => {
-    const sourceCode = `
-      <link href="a.css" rel="preload" as="style">
-    `;
-
-    const offenses = await runLiquidCheck(AssetPreload, sourceCode);
-    expect(offenses).to.have.lengthOf(1);
-    expect(offenses[0].message).to.equal(
-      'For better performance, prefer using the preload argument of the stylesheet_tag filter',
-    );
-
-    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
-    expect(highlights).to.eql([`<link href="a.css" rel="preload" as="style">`]);
-  });
-
-  it('reports image preloading', async () => {
-    const sourceCode = `
-      <link href="a.png" rel="preload" as="image">
-    `;
-
-    const offenses = await runLiquidCheck(AssetPreload, sourceCode);
-    expect(offenses).to.have.lengthOf(1);
-    expect(offenses[0].message).to.equal(
-      'For better performance, prefer using the preload argument of the image_tag filter',
-    );
-
-    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
-    expect(highlights).to.eql([`<link href="a.png" rel="preload" as="image">`]);
-  });
-
-  it('reports general preloading', async () => {
-    const sourceCode = `
-      <link href="a.js" rel="preload" as="script">
-    `;
-
-    const offenses = await runLiquidCheck(AssetPreload, sourceCode);
-    expect(offenses).to.have.lengthOf(1);
-    expect(offenses[0].message).to.equal(
-      'For better performance, prefer using the preload_tag filter',
-    );
-
-    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
-    expect(highlights).to.eql([`<link href="a.js" rel="preload" as="script">`]);
-  });
-
-  it('should report offenses for manual preloading of assets', async () => {
-    const sourceCode = `
-      <link href="{{ 'script.js' | asset_url }}" rel="preload" as="script">
-      <link href="{{ 'style.css' | asset_url }}" rel="preload" as="style">
-      <link href="{{ 'image.png' | asset_url }}" rel="preload" as="image">
-    `;
-
-    const offenses = await runLiquidCheck(AssetPreload, sourceCode);
-    expect(offenses).to.have.lengthOf(3);
-
-    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
-    expect(highlights).to.eql([
-      `<link href="{{ 'script.js' | asset_url }}" rel="preload" as="script">`,
-      `<link href="{{ 'style.css' | asset_url }}" rel="preload" as="style">`,
-      `<link href="{{ 'image.png' | asset_url }}" rel="preload" as="image">`,
-    ]);
-  });
-});