@jtl-software/eslint-plugin-posthog 0.1.1 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jtl-software/eslint-plugin-posthog",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "ESLint rules for PostHog event tracking best practices",
   "main": "src/index.js",
   "type": "module",

package/src/rules/consistent-property-naming.js

@@ -18,6 +18,9 @@ export default {
   },
 
   create(context) {
+    const wrapperFunctions = new Map();
+    const captureCalls = [];
+
     /**
      * Check if a string is in camelCase
      * @param {string} str - The string to check
@@ -43,30 +46,137 @@ export default {
       );
     }
 
+    function validateObjectProperties(objectNode) {
+      if (!objectNode || objectNode.type !== 'ObjectExpression') {
+        return;
+      }
+
+      objectNode.properties.forEach((prop) => {
+        if (prop.type === 'Property' && prop.key.type === 'Identifier') {
+          const propertyName = prop.key.name;
+          if (!isCamelCase(propertyName)) {
+            context.report({
+              node: prop.key,
+              messageId: 'notCamelCase',
+              data: {
+                property: propertyName,
+              },
+            });
+          }
+        }
+      });
+    }
+
+    function resolvePropertiesArgument(propertiesArg) {
+      if (!propertiesArg) {
+        return null;
+      }
+
+      // Direct object literal
+      if (propertiesArg.type === 'ObjectExpression') {
+        return propertiesArg;
+      }
+
+      // Variable reference - trace back to definition
+      if (propertiesArg.type === 'Identifier') {
+        const scope = context.sourceCode.getScope(propertiesArg);
+        const variable = scope.variables.find((v) => v.name === propertiesArg.name);
+
+        if (variable && variable.defs.length > 0) {
+          const def = variable.defs[0];
+          if (def.node.init && def.node.init.type === 'ObjectExpression') {
+            return def.node.init;
+          }
+        }
+      }
+
+      return null;
+    }
+
+    function getFunctionName(node) {
+      // Regular function declaration: function foo() {}
+      if (node.type === 'FunctionDeclaration' && node.id) {
+        return node.id.name;
+      }
+
+      // Variable declaration with arrow function: const foo = () => {}
+      // Variable declaration with function expression: const foo = function() {}
+      if (node.parent && node.parent.type === 'VariableDeclarator' && node.parent.id) {
+        return node.parent.id.name;
+      }
+
+      return null;
+    }
+
+    function getParentFunction(node) {
+      let current = node.parent;
+      while (current) {
+        if (
+          current.type === 'FunctionDeclaration' ||
+          current.type === 'FunctionExpression' ||
+          current.type === 'ArrowFunctionExpression'
+        ) {
+          return current;
+        }
+        current = current.parent;
+      }
+      return null;
+    }
+
+    const allCallExpressions = [];
+
     return {
       CallExpression(node) {
-        if (!isPostHogCapture(node)) {
-          return;
-        }
+        allCallExpressions.push(node);
 
-        // Second argument should be the properties object
-        const propertiesArg = node.arguments[1];
-        if (!propertiesArg || propertiesArg.type !== 'ObjectExpression') {
-          return;
+        if (isPostHogCapture(node)) {
+          captureCalls.push(node);
         }
+      },
+
+      'Program:exit'() {
+        captureCalls.forEach((captureCall) => {
+          const propertiesArg = captureCall.arguments[1];
+
+          if (propertiesArg && propertiesArg.type === 'Identifier') {
+            const parentFunc = getParentFunction(captureCall);
+            if (parentFunc) {
+              const paramName = propertiesArg.name;
+              const paramIndex = parentFunc.params.findIndex(
+                (p) => p.type === 'Identifier' && p.name === paramName,
+              );
+
+              if (paramIndex !== -1) {
+                const functionName = getFunctionName(parentFunc);
+                if (functionName) {
+                  wrapperFunctions.set(functionName, paramIndex);
+                }
+              }
+            }
+          }
+
+          // validate direct calls
+          const objectNode = resolvePropertiesArgument(propertiesArg);
+          if (objectNode) {
+            validateObjectProperties(objectNode);
+          }
+        });
+
+        // validate calls to wrapper functions
+        allCallExpressions.forEach((callNode) => {
+          if (isPostHogCapture(callNode)) {
+            return;
+          }
 
-        // Check each property in the object
-        propertiesArg.properties.forEach((prop) => {
-          if (prop.type === 'Property' && prop.key.type === 'Identifier') {
-            const propertyName = prop.key.name;
-            if (!isCamelCase(propertyName)) {
-              context.report({
-                node: prop.key,
-                messageId: 'notCamelCase',
-                data: {
-                  property: propertyName,
-                },
-              });
+          if (callNode.callee.type === 'Identifier') {
+            const functionName = callNode.callee.name;
+            if (wrapperFunctions.has(functionName)) {
+              const paramIndex = wrapperFunctions.get(functionName);
+              const propertiesArg = callNode.arguments[paramIndex];
+              const objectNode = resolvePropertiesArgument(propertiesArg);
+              if (objectNode) {
+                validateObjectProperties(objectNode);
+              }
             }
           }
         });

package/tests/rules/consistent-property-naming.test.js

@@ -23,6 +23,39 @@ ruleTester.run('consistent-property-naming', rule, {
       code: `// Not a PostHog call
                  someOtherFunction({ user_id: '123' })`,
     },
+    // Variable tracking - valid camelCase
+    {
+      code: `
+        const properties = { userId: '123', productName: 'Test' };
+        postHog.capture('event_name', properties);
+      `,
+    },
+    // Wrapper function - valid camelCase
+    {
+      code: `
+        function trackEvent(name, props) {
+          postHog.capture(name, props);
+        }
+        trackEvent('event_name', { userId: '123', productName: 'Test' });
+      `,
+    },
+    // Nested function with wrapper - valid camelCase
+    {
+      code: `
+        function Component() {
+          const handleCapture = (eventName, properties) => {
+            postHog.capture(eventName, properties);
+          };
+
+          function handleClick() {
+            handleCapture('button_clicked', {
+              buttonId: '123',
+              buttonName: 'Submit'
+            });
+          }
+        }
+      `,
+    },
   ],
 
   invalid: [
@@ -70,5 +103,117 @@ ruleTester.run('consistent-property-naming', rule, {
         },
       ],
     },
+    // Variable tracking scenarios
+    {
+      code: `
+        const properties = { user_id: '123' };
+        postHog.capture('event_name', properties);
+      `,
+      errors: [
+        {
+          messageId: 'notCamelCase',
+          data: { property: 'user_id' },
+        },
+      ],
+    },
+    {
+      code: `
+        const props = { product_id: '123', product_name: 'Test' };
+        postHog.capture('event_name', props);
+      `,
+      errors: [
+        {
+          messageId: 'notCamelCase',
+          data: { property: 'product_id' },
+        },
+        {
+          messageId: 'notCamelCase',
+          data: { property: 'product_name' },
+        },
+      ],
+    },
+    {
+      code: `
+        const eventProps = {
+          userId: '123',
+          product_name: 'Test',
+          is_active: true
+        };
+        postHog.capture('event_name', eventProps);
+      `,
+      errors: [
+        {
+          messageId: 'notCamelCase',
+          data: { property: 'product_name' },
+        },
+        {
+          messageId: 'notCamelCase',
+          data: { property: 'is_active' },
+        },
+      ],
+    },
+    // Wrapper function scenarios
+    {
+      code: `
+        function trackEvent(name, props) {
+          postHog.capture(name, props);
+        }
+        trackEvent('event_name', { user_id: '123' });
+      `,
+      errors: [
+        {
+          messageId: 'notCamelCase',
+          data: { property: 'user_id' },
+        },
+      ],
+    },
+    {
+      code: `
+        const handleCapture = (eventName, properties) => {
+          postHog.capture(eventName, properties);
+        };
+        handleCapture('product_added', {
+          product_id: '123',
+          product_name: 'Test'
+        });
+      `,
+      errors: [
+        {
+          messageId: 'notCamelCase',
+          data: { property: 'product_id' },
+        },
+        {
+          messageId: 'notCamelCase',
+          data: { property: 'product_name' },
+        },
+      ],
+    },
+    // Nested function scenario (like the original bug report)
+    {
+      code: `
+        function Component() {
+          const handleCapture = (eventName, properties) => {
+            postHog.capture(eventName, properties);
+          };
+
+          function handleClick() {
+            handleCapture('button_clicked', {
+              button_id: '123',
+              button_name: 'Submit'
+            });
+          }
+        }
+      `,
+      errors: [
+        {
+          messageId: 'notCamelCase',
+          data: { property: 'button_id' },
+        },
+        {
+          messageId: 'notCamelCase',
+          data: { property: 'button_name' },
+        },
+      ],
+    },
   ],
 });