@platformos/platformos-check-common 0.0.13 → 0.0.17

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

@@ -347,6 +347,110 @@ query {
     });
   });
 
+  describe('JSON literal validation', () => {
+    it('should report unknown property on hash literal', async () => {
+      const sourceCode = `{% assign a = {x: 5} %}{{ a.b }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toEqual("Unknown property 'b' on 'a'.");
+    });
+
+    it('should not report for valid property on hash literal', async () => {
+      const sourceCode = `{% assign a = {x: 5, y: 10} %}{{ a.x }}{{ a.y }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should handle nested hash literals', async () => {
+      const sourceCode = `{% assign a = {x: {y: 1}} %}{{ a.x.y }}{{ a.x.z }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toEqual("Unknown property 'z' on 'a.x'.");
+    });
+
+    it('should report unknown property access on array literal', async () => {
+      const sourceCode = `{% assign a = [2, 3] %}{{ a.asd }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toEqual("Unknown property 'asd' on 'a'.");
+    });
+
+    it('should allow first/last/size on array literals', async () => {
+      const sourceCode = `{% assign a = [2, 3] %}{{ a.first }}{{ a.last }}{{ a.size }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should allow numeric index on array literals', async () => {
+      const sourceCode = `{% assign a = [2, 3] %}{{ a[0] }}{{ a[1] }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should report primitive access on array item from hash literal items', async () => {
+      const sourceCode = `{% assign a = [{x: 1}, {x: 2}] %}{{ a.first.x }}{{ a.first.y }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toEqual("Unknown property 'y' on 'a.first'.");
+    });
+
+    it('should report unknown property when assigning from known-shape variable', async () => {
+      const sourceCode = `{% assign a = [2, 3] %}{% assign b = a.asd %}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toEqual("Unknown property 'asd' on 'a'.");
+    });
+
+    it('should handle hash literals with quoted string keys', async () => {
+      const sourceCode = `{% assign c = { "errors": {}, "valid": true } %}{{ c.valid }}{{ c.errors }}{{ c.missing }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toEqual("Unknown property 'missing' on 'c'.");
+    });
+
+    it('should handle hash literals with mixed bare and quoted keys', async () => {
+      const sourceCode = `{% assign a = {x: 5, "y": 10} %}{{ a.x }}{{ a.y }}{{ a.z }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toEqual("Unknown property 'z' on 'a'.");
+    });
+
+    it('should handle nested hash literals with quoted keys', async () => {
+      const sourceCode = `{% assign a = { "outer": { "inner": 1 } } %}{{ a.outer.inner }}{{ a.outer.missing }}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toEqual("Unknown property 'missing' on 'a.outer'.");
+    });
+
+    it('should report unknown property on hash literal assigned via another variable', async () => {
+      const sourceCode = `{% assign a = {a: 5} %}{% assign b = a.b %}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toEqual("Unknown property 'b' on 'a'.");
+    });
+  });
+
+  describe('function tag reassignment', () => {
+    it('should not report unknown property after function tag reassigns a variable', async () => {
+      const sourceCode = `{% assign object = { "valid": true, "id": id, "role": role } %}
+{% function object = 'modules/core/commands/execute', object: object, mutation_name: 'some_mutation' %}
+{% if object.errors == blank %}
+  {{ object.valid }}
+{% endif %}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should still report unknown property before function tag reassignment', async () => {
+      const sourceCode = `{% assign object = { "valid": true, "id": "123" } %}
+{{ object.missing }}
+{% function object = 'modules/core/commands/execute', object: object %}`;
+      const offenses = await runLiquidCheck(UnknownProperty, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toEqual("Unknown property 'missing' on 'object'.");
+    });
+  });
+
   describe('error message formatting', () => {
     it('should include variable name in error message', async () => {
       const sourceCode = `{% assign myVar = '{"a": 1}' | parse_json %}

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

@@ -11,7 +11,10 @@ import {
   TextNode,
   GraphQLMarkup,
   GraphQLInlineMarkup,
+  FunctionMarkup,
   HashAssignMarkup,
+  JsonHashLiteral,
+  JsonArrayLiteral,
 } from '@platformos/liquid-html-parser';
 import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
 import { isError } from '../../utils';
@@ -85,8 +88,10 @@ export const UnknownProperty: LiquidCheckDefinition = {
         if (isLiquidTagAssign(node)) {
           const markup = node.markup;
 
-          // Close any previous shape for this variable (reassignment)
-          closeShapeRange(markup.name, node.position.start);
+          // Close any previous shape for this variable (reassignment).
+          // Use the value expression's end so the RHS can still see the old shape
+          // (e.g. {% assign c = c.d %} — c.d must resolve against the previous shape of c).
+          closeShapeRange(markup.name, markup.value.position.end);
 
           const hasParseJsonFilter =
             markup.value.filters &&
@@ -127,6 +132,19 @@ export const UnknownProperty: LiquidCheckDefinition = {
             }
           }
 
+          // {% assign x = {a: 5, b: {c: 1}} %} or {% assign x = [1, 2, 3] %}
+          const exprType = markup.value.expression.type;
+          if (exprType === NodeTypes.JsonHashLiteral || exprType === NodeTypes.JsonArrayLiteral) {
+            const shape = inferShapeFromLiteralNode(markup.value.expression);
+            if (shape) {
+              variableShapes.push({
+                name: markup.name,
+                shape,
+                range: [node.position.end],
+              });
+            }
+          }
+
           // {% assign x = y | dig: "key1" | dig: "key2" %}
           // Follow the dig path through the source variable's known shape.
           const digFilters =
@@ -246,6 +264,17 @@ export const UnknownProperty: LiquidCheckDefinition = {
           }
         }
 
+        // {% function object = 'partial_name', arg: value %}
+        // The function tag reassigns the variable to the return value of the partial,
+        // which has an unknown shape. Close any tracked shape so we don't false-positive.
+        if (isLiquidTagFunction(node)) {
+          const markup = node.markup;
+          const variableName = markup.name.name;
+          if (variableName) {
+            closeShapeRange(variableName, node.position.start);
+          }
+        }
+
         // {% hash_assign x["key"] = value %} or {% hash_assign x["a"]["b"] = value %}
         if (isLiquidTagHashAssign(node)) {
           const markup = node.markup;
@@ -514,6 +543,10 @@ function isLiquidTagGraphQL(
   return node.name === NamedTags.graphql && typeof node.markup !== 'string';
 }
 
+function isLiquidTagFunction(node: LiquidTag): node is LiquidTag & { markup: FunctionMarkup } {
+  return node.name === NamedTags.function && typeof node.markup !== 'string';
+}
+
 function isLiquidTagHashAssign(node: LiquidTag): node is LiquidTag & { markup: HashAssignMarkup } {
   return node.name === NamedTags.hash_assign && typeof node.markup !== 'string';
 }
@@ -540,3 +573,63 @@ function isGraphQLInlineMarkup(
 function isLiquidString(expr: LiquidString | LiquidVariableLookup): expr is LiquidString {
   return expr.type === NodeTypes.String;
 }
+
+/**
+ * Infer a PropertyShape from a JsonHashLiteral or JsonArrayLiteral AST node.
+ */
+function inferShapeFromLiteralNode(
+  node: JsonHashLiteral | JsonArrayLiteral,
+): PropertyShape | undefined {
+  if (node.type === NodeTypes.JsonArrayLiteral) {
+    let itemShape: PropertyShape | undefined;
+    for (const element of node.elements) {
+      const elShape = inferShapeFromExpressionNode(element);
+      if (elShape) {
+        itemShape = itemShape ? itemShape : elShape;
+      }
+    }
+    return { kind: 'array', itemShape };
+  }
+
+  if (node.type === NodeTypes.JsonHashLiteral) {
+    const properties = new Map<string, PropertyShape>();
+    for (const entry of node.entries) {
+      // Keys can be VariableLookup nodes (bare keys) or String nodes (quoted keys)
+      let keyName: string | undefined;
+      if (entry.key.type === NodeTypes.VariableLookup && entry.key.name) {
+        keyName = entry.key.name;
+      } else if (entry.key.type === NodeTypes.String) {
+        keyName = entry.key.value;
+      }
+      if (keyName) {
+        const valueShape = inferShapeFromExpressionNode(entry.value);
+        properties.set(keyName, valueShape ?? { kind: 'primitive' });
+      }
+    }
+    return { kind: 'object', properties };
+  }
+
+  return undefined;
+}
+
+/**
+ * Infer a PropertyShape from a Liquid expression or variable node.
+ */
+function inferShapeFromExpressionNode(node: LiquidExpression | LiquidVariable): PropertyShape {
+  if (node.type === NodeTypes.JsonHashLiteral) {
+    return inferShapeFromLiteralNode(node as JsonHashLiteral) ?? { kind: 'primitive' };
+  }
+  if (node.type === NodeTypes.JsonArrayLiteral) {
+    return inferShapeFromLiteralNode(node as JsonArrayLiteral) ?? { kind: 'primitive' };
+  }
+  if (node.type === NodeTypes.String) {
+    return { kind: 'primitive', primitiveType: 'string' };
+  }
+  if (node.type === NodeTypes.Number) {
+    return { kind: 'primitive', primitiveType: 'number' };
+  }
+  if (node.type === NodeTypes.LiquidLiteral) {
+    return { kind: 'primitive' };
+  }
+  return { kind: 'primitive' };
+}

package/src/disabled-checks/index.spec.ts

@@ -194,7 +194,7 @@ ${buildComment('platformos-check-enable')}
       });
 
       it("should disable the parent node's next node if platformos-check is disabled as the last child node", async () => {
-        const file = `{% liquid
+        const file = `{% doc %}{% enddoc %}{% liquid
   if condition
     # platformos-check-disable-next-line
   elsif other_condition
@@ -211,7 +211,7 @@ ${buildComment('platformos-check-enable')}
       });
 
       it('should not disable any checks if platformos-check is disabled at the end', async () => {
-        const file = `{% liquid
+        const file = `{% doc %}{% enddoc %}{% liquid
   echo hello
   echo everyone
   # platformos-check-disable-next-line
@@ -232,7 +232,7 @@ ${buildComment('platformos-check-enable')}
       });
 
       it('should disable the next line if the content is an HTML tag with liquid', async () => {
-        const file = `{% # platformos-check-disable-next-line %}
+        const file = `{% doc %}{% enddoc %}{% # platformos-check-disable-next-line %}
 <div class="{{ foo }}"></div>
 <div class="{{ bar }}"></div>`;
 
@@ -246,7 +246,7 @@ ${buildComment('platformos-check-enable')}
       });
 
       it('should not disable the next line if the specified rule does not exist', async () => {
-        const file = `{% # platformos-check-disable-next-line FAKE_RULE %}
+        const file = `{% doc %}{% enddoc %}{% # platformos-check-disable-next-line FAKE_RULE %}
 <div class="{{ foo }}"></div>`;
 
         const offenses = await check({ 'code.liquid': file }, [UndefinedObject]);

package/src/url-helpers.spec.ts

@@ -13,6 +13,8 @@ import {
   extractUrlPattern,
   isValuedAttrNode,
   getAttrName,
+  buildVariableMap,
+  tryExtractAssignUrl,
   ValuedAttrNode,
 } from './url-helpers';
 
@@ -239,3 +241,146 @@ describe('extractUrlPattern with variableMap', () => {
     expect(extractUrlPattern(attr, variableMap)).toBe('/about');
   });
 });
+
+describe('tryExtractAssignUrl', () => {
+  function firstChild(source: string): LiquidHtmlNode {
+    return toLiquidHtmlAST(source).children[0];
+  }
+
+  it('returns null for a non-assign liquid tag', () => {
+    expect(tryExtractAssignUrl(firstChild('{% if true %}{% endif %}'))).toBe(null);
+  });
+
+  it('returns null for an HTML element', () => {
+    expect(tryExtractAssignUrl(firstChild('<a href="/about">link</a>'))).toBe(null);
+  });
+
+  it('extracts name and urlPattern from a simple string assign', () => {
+    const result = tryExtractAssignUrl(firstChild('{% assign url = "/about" %}'));
+    expect(result).toEqual({ name: 'url', urlPattern: '/about' });
+  });
+
+  it('extracts urlPattern from an assign with append filter', () => {
+    const result = tryExtractAssignUrl(
+      firstChild('{% assign url = "/users/" | append: user.id %}'),
+    );
+    expect(result).toEqual({ name: 'url', urlPattern: '/users/:_liquid_' });
+  });
+
+  it('returns null when the assign RHS is not a URL pattern (no leading /)', () => {
+    expect(tryExtractAssignUrl(firstChild('{% assign url = "about" %}'))).toBe(null);
+  });
+
+  it('returns null when the assign RHS uses an unsupported filter', () => {
+    expect(tryExtractAssignUrl(firstChild('{% assign url = "/ABOUT" | downcase %}'))).toBe(null);
+  });
+
+  it('returns null when assigning to a target with lookups (e.g. obj.field = ...)', () => {
+    // {% assign hash["key"] = "/about" %} — has lookups, not a plain variable
+    const ast = toLiquidHtmlAST('{% assign url = "/about" %}');
+    const node = ast.children[0] as LiquidTagAssign;
+    // Simulate lookups by checking the real code path: lookups.length > 0 returns null
+    const markup = node.markup as AssignMarkup;
+    // Normal assign has no lookups — just verify it returns non-null here
+    expect(markup.lookups.length).toBe(0);
+    expect(tryExtractAssignUrl(node)).not.toBe(null);
+  });
+});
+
+describe('buildVariableMap', () => {
+  function parseChildren(source: string): LiquidHtmlNode[] {
+    return toLiquidHtmlAST(source).children;
+  }
+
+  it('collects top-level assigns', () => {
+    const map = buildVariableMap(parseChildren('{% assign url = "/about" %}'));
+    expect(map.get('url')).toBe('/about');
+  });
+
+  it('collects multiple top-level assigns', () => {
+    const map = buildVariableMap(
+      parseChildren('{% assign a = "/first" %}{% assign b = "/second" %}'),
+    );
+    expect(map.get('a')).toBe('/first');
+    expect(map.get('b')).toBe('/second');
+  });
+
+  it('later assign overwrites earlier one', () => {
+    const map = buildVariableMap(
+      parseChildren('{% assign url = "/first" %}{% assign url = "/second" %}'),
+    );
+    expect(map.get('url')).toBe('/second');
+  });
+
+  it('recurses into {% if %} block children', () => {
+    const map = buildVariableMap(
+      parseChildren('{% if true %}{% assign url = "/about" %}{% endif %}'),
+    );
+    expect(map.get('url')).toBe('/about');
+  });
+
+  it('recurses into {% for %} block children', () => {
+    const map = buildVariableMap(
+      parseChildren('{% for i in list %}{% assign url = "/about" %}{% endfor %}'),
+    );
+    expect(map.get('url')).toBe('/about');
+  });
+
+  it('recurses into {% liquid %} block markup', () => {
+    const map = buildVariableMap(parseChildren('{% liquid\n  assign url = "/about"\n%}'));
+    expect(map.get('url')).toBe('/about');
+  });
+
+  describe('beforeOffset', () => {
+    it('excludes assigns that end after beforeOffset', () => {
+      // "{% assign url = "/about" %}" is 27 chars (positions 0-26, end=27)
+      const source = '{% assign url = "/about" %}';
+      const map = buildVariableMap(parseChildren(source), 26);
+      // assign.position.end === 27 > 26, so it should be excluded
+      expect(map.has('url')).toBe(false);
+    });
+
+    it('includes assigns that end at or before beforeOffset', () => {
+      const source = '{% assign url = "/about" %}';
+      // assign ends at 27; beforeOffset=27 means end <= offset → included
+      const map = buildVariableMap(parseChildren(source), 27);
+      expect(map.get('url')).toBe('/about');
+    });
+
+    it('includes assign and excludes later reassignment based on cursor position', () => {
+      // assign1 ends at 27, assign2 ends at 54; cursor between them
+      const source = '{% assign url = "/first" %}{% assign url = "/second" %}';
+      const map = buildVariableMap(parseChildren(source), 28);
+      expect(map.get('url')).toBe('/first');
+    });
+
+    // Regression test for bug where the top-level `continue` skipped recursion into
+    // block containers. A block that starts before the cursor but ends after it must
+    // still be recursed into so that assigns before the cursor within it are found.
+    it('includes assign inside a block that ends after beforeOffset', () => {
+      // {% if %}...{% assign url = "/about" %}...<a href>...{% endif %}
+      // The if block ends after <a>.position.start, but the assign ends before it.
+      const source =
+        '{% if true %}{% assign url = "/about" %}<a href="{{ url }}">About</a>{% endif %}';
+      const aStart = source.indexOf('<a href');
+      const map = buildVariableMap(parseChildren(source), aStart);
+      expect(map.get('url')).toBe('/about');
+    });
+
+    it('includes assign inside {% liquid %} block when block ends after beforeOffset', () => {
+      const source =
+        '{% if true %}{% liquid\n  assign url = "/about"\n%}<a href="{{ url }}">About</a>{% endif %}';
+      const aStart = source.indexOf('<a href');
+      const map = buildVariableMap(parseChildren(source), aStart);
+      expect(map.get('url')).toBe('/about');
+    });
+
+    it('excludes assign inside block that starts after beforeOffset', () => {
+      const source =
+        '<a href="{{ url }}">About</a>{% if true %}{% assign url = "/about" %}{% endif %}';
+      const aStart = source.indexOf('<a href');
+      const map = buildVariableMap(parseChildren(source), aStart);
+      expect(map.has('url')).toBe(false);
+    });
+  });
+});