@platformos/platformos-check-common 0.0.2

package/src/checks/unique-static-block-id/index.spec.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { runLiquidCheck } from '../../test';
+import { UniqueStaticBlockId } from './index';
+
+describe('Module: UniqueStaticBlockId', () => {
+  it('should report an error when two static blocks have the same id', async () => {
+    const sourceCode = `
+     {% content_for "block", type: "text", id: "static-block" %}
+     {% content_for "block", type: "text", id: "static-block" %}
+    `;
+
+    const offenses = await runLiquidCheck(UniqueStaticBlockId, sourceCode);
+
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal(
+      "The id 'static-block' is already being used by another static block",
+    );
+  });
+
+  it('should not report an error when two static blocks have differnt id', async () => {
+    const sourceCode = `
+     {% content_for "block", type: "text", id: "static-block1" %}
+     {% content_for "block", type: "text", id: "static-block2" %}
+    `;
+
+    const offenses = await runLiquidCheck(UniqueStaticBlockId, sourceCode);
+
+    expect(offenses).to.have.length(0);
+  });
+
+  it('should report an error when two static blocks have same id and different types', async () => {
+    const sourceCode = `
+     {% content_for "block", type: "text", id: "static-block" %}
+     {% content_for "block", type: "url", id: "static-block" %}
+    `;
+
+    const offenses = await runLiquidCheck(UniqueStaticBlockId, sourceCode);
+
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal(
+      "The id 'static-block' is already being used by another static block",
+    );
+  });
+
+  it('should not report an error when two static blocks have different id and different types', async () => {
+    const sourceCode = `
+     {% content_for "block", type: "text", id: "static-block1" %}
+     {% content_for "block", type: "url", id: "static-block2" %}
+    `;
+
+    const offenses = await runLiquidCheck(UniqueStaticBlockId, sourceCode);
+
+    expect(offenses).to.have.length(0);
+  });
+});

package/src/checks/unique-static-block-id/index.ts

@@ -0,0 +1,60 @@
+import { NamedTags, NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
+import { isContentForBlock } from '../../utils/markup';
+
+export const UniqueStaticBlockId: LiquidCheckDefinition = {
+  meta: {
+    code: 'UniqueStaticBlockId',
+    name: 'Prevent use of duplicated ids for blocks rendered statically',
+    docs: {
+      description:
+        'This check is aimed at preventing the use of duplicated ids for blocks rendered statically.',
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/unique-static-block-id',
+      recommended: true,
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.ERROR,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    const usedIds: Set<string> = new Set();
+    const idRegex = /id:\s*["'](\S+)["']/;
+    return {
+      async LiquidTag(node) {
+        if (node.name !== NamedTags.content_for) {
+          return;
+        }
+
+        if (!isContentForBlock(node.markup)) {
+          return;
+        }
+
+        const idNode = node.markup.args.find((arg) => arg.name === 'id');
+
+        if (!idNode) {
+          return; // covered by VariableContentForArguments
+        }
+
+        const idValueNode = idNode.value;
+        if (idValueNode.type !== NodeTypes.String) {
+          return; // covered by VariableContentForArguments
+        }
+
+        const id = idValueNode.value;
+
+        if (usedIds.has(id)) {
+          context.report({
+            message: `The id '${id}' is already being used by another static block`,
+            startIndex: idValueNode.position.start,
+            endIndex: idValueNode.position.end,
+            suggest: [],
+          });
+        } else {
+          usedIds.add(id);
+        }
+      },
+    };
+  },
+};

package/src/checks/unknown-filter/index.spec.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import { runLiquidCheck, highlightedOffenses } from '../../test';
+import { UnknownFilter } from './index';
+
+describe('Module: UnknownFilter', () => {
+  it('should report an offense when an unknown filter is used', async () => {
+    const sourceCode = `{{ "hello" | unknown_filter }}`;
+    const offenses = await runLiquidCheck(UnknownFilter, sourceCode);
+    expect(offenses).toHaveLength(1);
+    expect(offenses[0].message).toBe("Unknown filter 'unknown_filter' used.");
+
+    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
+    expect(highlights[0]).to.eql('| unknown_filter');
+  });
+
+  it('reports on unknown filter', async () => {
+    const sourceCode = `{{ "foo" | bar }}`;
+    const offenses = await runLiquidCheck(UnknownFilter, sourceCode);
+    expect(offenses).toHaveLength(1);
+    expect(offenses[0].message).toBe("Unknown filter 'bar' used.");
+
+    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
+    expect(highlights[0]).to.eql('| bar');
+  });
+
+  it('reports on unknown filter chained with known filters', async () => {
+    const sourceCode = `{{ "foo" | append: ".js" | bar }}`;
+    const offenses = await runLiquidCheck(UnknownFilter, sourceCode);
+    expect(offenses).toHaveLength(1);
+    expect(offenses[0].message).toBe("Unknown filter 'bar' used.");
+
+    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
+    expect(highlights[0]).to.eql('| bar');
+  });
+
+  it('does not report on chain of known filters', async () => {
+    const sourceCode = `{{ "foo" | append: ".js" | item_count_for_variant }}`;
+    const offenses = await runLiquidCheck(UnknownFilter, sourceCode);
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should not report an offense when a known filter is used (0)', async () => {
+    const sourceCode = `{{ 'hello' | item_count_for_variant }}`;
+    const offenses = await runLiquidCheck(UnknownFilter, sourceCode);
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should not report an offense when a known filter is used (1)', async () => {
+    const sourceCode = `{{ 'hello' | link_to_type }}`;
+    const offenses = await runLiquidCheck(UnknownFilter, sourceCode);
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should not report an offense when a known filter is used (2)', async () => {
+    const sourceCode = `{{ 'hello' | link_to_vendor }}`;
+    const offenses = await runLiquidCheck(UnknownFilter, sourceCode);
+    expect(offenses).toHaveLength(0);
+  });
+});

package/src/checks/unknown-filter/index.ts

@@ -0,0 +1,38 @@
+// src/checks/unknown-filter/index.ts
+import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
+
+export const UnknownFilter: LiquidCheckDefinition = {
+  meta: {
+    code: 'UnknownFilter',
+    name: 'Prevent use of unknown filters',
+    docs: {
+      description: 'This check is aimed at preventing the use of unknown filters.',
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/unknown-filter',
+      recommended: true,
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.ERROR,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    if (!context.themeDocset) {
+      return {};
+    }
+
+    return {
+      async LiquidFilter(node) {
+        const knownFilters = await context.themeDocset!.filters();
+
+        if (!knownFilters.some((filter) => filter.name === node.name)) {
+          context.report({
+            message: `Unknown filter '${node.name}' used.`,
+            startIndex: node.position.start + 1,
+            endIndex: node.position.end,
+          });
+        }
+      },
+    };
+  },
+};

package/src/checks/unknown-property/index.spec.ts

@@ -0,0 +1,234 @@
+import { describe, it, expect } from 'vitest';
+import { runLiquidCheck, highlightedOffenses } from '../../test';
+import { UnknownProperty } from './index';
+
+describe('Module: UnknownProperty', () => {
+  describe('JSON literal validation', () => {
+    it('should report unknown property on JSON object', async () => {
+      const sourceCode = `{% assign a = '{"x": 5}' | parse_json %}
+{{ a.x }}
+{{ a.y }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Unknown property 'y'");
+      expect(offenses[0].message).toContain("'a'");
+    });
+
+    it('should not report for valid property access', async () => {
+      const sourceCode = `{% assign a = '{"x": 5, "y": 10}' | parse_json %}
+{{ a.x }}
+{{ a.y }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should report property access on primitive', async () => {
+      const sourceCode = `{% assign a = '{"x": 5}' | parse_json %}
+{{ a.x.y }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain('primitive value');
+      expect(offenses[0].message).toContain("'a.x'");
+    });
+
+    it('should handle nested objects', async () => {
+      const sourceCode = `{% assign a = '{"x": {"y": {"z": 1}}}' | parse_json %}
+{{ a.x.y.z }}
+{{ a.x.y.w }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Unknown property 'w'");
+      expect(offenses[0].message).toContain("'a.x.y'");
+    });
+
+    it('should handle arrays with first/last/size', async () => {
+      const sourceCode = `{% assign a = '[{"x": 1}, {"x": 2}]' | parse_json %}
+{{ a.first.x }}
+{{ a.last.x }}
+{{ a.size }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should report unknown property on array item', async () => {
+      const sourceCode = `{% assign a = '[{"x": 1}, {"x": 2}]' | parse_json %}
+{{ a.first.y }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Unknown property 'y'");
+    });
+
+    it('should handle numeric index access on arrays', async () => {
+      const sourceCode = `{% assign a = '[{"x": 1}, {"x": 2}]' | parse_json %}
+{{ a[0].x }}
+{{ a[1].y }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Unknown property 'y'");
+    });
+
+    it('should not report for dynamic variables', async () => {
+      const sourceCode = `{{ some_dynamic_var.anything }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should not report for invalid JSON', async () => {
+      const sourceCode = `{% assign a = 'not valid json' %}
+{{ a.x }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should not report when JSON is not a string literal', async () => {
+      const sourceCode = `{% assign a = some_variable %}
+{{ a.x }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should handle variable reassignment', async () => {
+      const sourceCode = `{% assign a = '{"x": 1}' | parse_json %}
+{{ a.x }}
+{% assign a = '{"y": 2}' | parse_json %}
+{{ a.y }}
+{{ a.x }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Unknown property 'x'");
+    });
+
+    it('should not validate dynamic lookup paths', async () => {
+      const sourceCode = `{% assign a = '{"x": 1}' %}
+{% assign key = "x" %}
+{{ a[key] }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+  });
+
+  describe('parse_json validation', () => {
+    it('should validate parse_json block content', async () => {
+      const sourceCode = `{% parse_json data %}
+{"name": "test", "value": 42}
+{% endparse_json %}
+{{ data.name }}
+{{ data.missing }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Unknown property 'missing'");
+    });
+
+    it('should not report for valid parse_json properties', async () => {
+      const sourceCode = `{% parse_json data %}
+{"name": "test", "value": 42}
+{% endparse_json %}
+{{ data.name }}
+{{ data.value }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should handle nested objects in parse_json', async () => {
+      const sourceCode = `{% parse_json data %}
+{"user": {"name": "John", "age": 30}}
+{% endparse_json %}
+{{ data.user.name }}
+{{ data.user.email }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Unknown property 'email'");
+    });
+  });
+
+  describe('graphql inline validation', () => {
+    it('should validate direct graphql field access', async () => {
+      // Note: Without schema, we can't know if a field returns an array or object.
+      // We only validate direct property access on the response shape.
+      const sourceCode = `{% graphql result %}
+query {
+  user {
+    id
+    name
+  }
+}
+{% endgraphql %}
+{{ result.user.id }}
+{{ result.user.email }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Unknown property 'email'");
+    });
+
+    it('should not report for valid graphql fields', async () => {
+      const sourceCode = `{% graphql result %}
+query {
+  user {
+    id
+    name
+    email
+  }
+}
+{% endgraphql %}
+{{ result.user.id }}
+{{ result.user.name }}
+{{ result.user.email }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should handle nested graphql selections', async () => {
+      const sourceCode = `{% graphql result %}
+query {
+  user {
+    profile {
+      firstName
+      lastName
+    }
+  }
+}
+{% endgraphql %}
+{{ result.user.profile.firstName }}
+{{ result.user.profile.middleName }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Unknown property 'middleName'");
+    });
+
+    it('should not validate array access on graphql fields (no schema info)', async () => {
+      // Since we don't have schema info, we can't validate .first/.last access
+      // on GraphQL results - we don't know if the field returns an array
+      const sourceCode = `{% graphql result %}
+query {
+  users {
+    id
+    name
+  }
+}
+{% endgraphql %}
+{{ result.users.first.anything }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      // Currently this reports an error because 'first' is not in the users object
+      // This is expected behavior without schema - we can't know users is an array
+      expect(offenses).toHaveLength(1);
+    });
+  });
+
+  describe('error message formatting', () => {
+    it('should include variable name in error message', async () => {
+      const sourceCode = `{% assign myVar = '{"a": 1}' | parse_json %}
+{{ myVar.b }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("'myVar'");
+    });
+
+    it('should include full path for nested access errors', async () => {
+      const sourceCode = `{% assign obj = '{"a": {"b": 1}}' | parse_json %}
+{{ obj.a.c }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("'obj.a'");
+    });
+  });
+});