@platformos/platformos-check-common 0.0.16 → 0.0.18

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

@@ -401,6 +401,27 @@ query {
       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);
@@ -409,6 +430,27 @@ query {
     });
   });
 
+  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,6 +11,7 @@ import {
   TextNode,
   GraphQLMarkup,
   GraphQLInlineMarkup,
+  FunctionMarkup,
   HashAssignMarkup,
   JsonHashLiteral,
   JsonArrayLiteral,
@@ -263,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;
@@ -531,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';
 }
@@ -578,10 +594,16 @@ function inferShapeFromLiteralNode(
   if (node.type === NodeTypes.JsonHashLiteral) {
     const properties = new Map<string, PropertyShape>();
     for (const entry of node.entries) {
-      // Keys are VariableLookup nodes where the name is the key string
+      // 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(entry.key.name, valueShape ?? { kind: 'primitive' });
+        properties.set(keyName, valueShape ?? { kind: 'primitive' });
       }
     }
     return { kind: 'object', properties };