Enhance TypeScript tracking detection with improved function and event matching

Co-authored-by: sameenkarim <[email protected]>

Author: cursoragent

package.json

@@ -9,7 +9,7 @@
   "scripts": {
     "test": "node tests",
     "test:js": "node --test tests/analyzeJavaScript.test.js",
-    "test:ts": "node --test tests/analyzeTypeScript.test.js",
+    "test:ts": "node --test tests/analyzeTypeScript.test.js tests/trackUserEvent.test.js",
     "test:python": "node --experimental-vm-modules --test tests/analyzePython.test.js",
     "test:ruby": "node --experimental-vm-modules --test tests/analyzeRuby.test.js",
     "test:go": "node --test tests/analyzeGo.test.js",

src/analyze/javascript/detectors/analytics-source.js

@@ -50,7 +50,19 @@ function isCustomFunction(node, customFunction) {
 
   // Simple identifier (no dot)
   if (parts.length === 1) {
-    return node.callee.type === NODE_TYPES.IDENTIFIER && node.callee.name === customFunction;
+    // If callee is a simple identifier, match directly
+    if (node.callee.type === NODE_TYPES.IDENTIFIER && node.callee.name === customFunction) {
+      return true;
+    }
+
+    // If callee is a MemberExpression, allow matching on the right-most property when it matches
+    if (node.callee.type === NODE_TYPES.MEMBER_EXPRESSION &&
+        node.callee.property.type === NODE_TYPES.IDENTIFIER &&
+        node.callee.property.name === customFunction) {
+      return true;
+    }
+
+    return false;
   }
 
   // For dot-separated names, the callee should be a MemberExpression chain.
@@ -91,6 +103,9 @@ function matchesMemberChain(memberExpr, parts) {
     } else if (currentNode.type === NODE_TYPES.IDENTIFIER) {
       // We reached the leftmost Identifier; it should match the first part
       return idx === 0 && currentNode.name === expectedPart;
+    } else if (currentNode.type === 'ThisExpression') {
+      // Support chains starting with "this" (e.g., this.props.trackUserEvent)
+      return idx === 0 && expectedPart === 'this';
     } else {
       // Unexpected node type (e.g., ThisExpression, CallExpression, etc.)
       return false;

src/analyze/typescript/detectors/analytics-source.js

@@ -44,6 +44,34 @@ function detectAnalyticsSource(node, customFunction) {
  * @returns {boolean}
  */
 function isCustomFunction(node, customFunction) {
+  if (!customFunction) return false;
+
+  // ------------------------------------------------------------------
+  // If the customFunction string does not include a dot, treat it as a
+  // short name and match calls where the right-most property (or the
+  // identifier itself) equals the name. This covers patterns like:
+  //   trackUserEvent(...)
+  //   this.props.trackUserEvent(...)
+  // ------------------------------------------------------------------
+  if (!customFunction.includes('.')) {
+    // Direct identifier call
+    if (ts.isIdentifier(node.expression) && node.expression.escapedText === customFunction) {
+      return true;
+    }
+
+    // PropertyAccessExpression – check the final name
+    if (ts.isPropertyAccessExpression(node.expression) && node.expression.name.escapedText === customFunction) {
+      return true;
+    }
+
+    return false;
+  }
+
+  // ------------------------------------------------------------------
+  // For fully qualified names (with dots), we rely on exact text match –
+  // this keeps behaviour unchanged for signatures like
+  // "CustomModule.track".
+  // ------------------------------------------------------------------
   const canBeCustomFunction = ts.isIdentifier(node.expression) ||
     ts.isPropertyAccessExpression(node.expression) ||
     ts.isCallExpression(node.expression) || // For chained calls like getTracker().track()

src/analyze/typescript/extractors/event-extractor.js

@@ -186,26 +186,27 @@ function extractDefaultEvent(node, checker, sourceFile) {
 function processEventData(eventData, source, filePath, line, functionName, checker, sourceFile, customConfig) {
   const { eventName, propertiesNode } = eventData;
 
-  if (!eventName || !propertiesNode) {
+  if (!eventName) {
     return null;
   }
 
   let properties = null;
 
   // Check if properties is an object literal
-  if (ts.isObjectLiteralExpression(propertiesNode)) {
+  if (propertiesNode && ts.isObjectLiteralExpression(propertiesNode)) {
     properties = extractProperties(checker, propertiesNode);
   }
   // Check if properties is an identifier (variable reference)
-  else if (ts.isIdentifier(propertiesNode)) {
+  else if (propertiesNode && ts.isIdentifier(propertiesNode)) {
     const resolvedNode = resolveIdentifierToInitializer(checker, propertiesNode, sourceFile);
     if (resolvedNode && ts.isObjectLiteralExpression(resolvedNode)) {
       properties = extractProperties(checker, resolvedNode);
     }
   }
 
   if (!properties) {
-    return null;
+    // If propertiesNode was missing or could not be resolved, default to empty object
+    properties = {};
   }
 
   // Special handling for Snowplow: remove 'action' from properties
@@ -296,27 +297,78 @@ function resolvePropertyAccessToString(node, checker, sourceFile) {
   try {
     // Get the symbol for the property access
     const symbol = checker.getSymbolAtLocation(node);
-    if (!symbol || !symbol.valueDeclaration) {
-      return null;
-    }
-    
-    // Check if it's a property assignment with a string initializer
-    if (ts.isPropertyAssignment(symbol.valueDeclaration) && 
-        symbol.valueDeclaration.initializer &&
-        ts.isStringLiteral(symbol.valueDeclaration.initializer)) {
-      return symbol.valueDeclaration.initializer.text;
+    if (symbol && symbol.valueDeclaration) {
+      // Check if it's a property assignment with a string initializer
+      if (ts.isPropertyAssignment(symbol.valueDeclaration) && 
+          symbol.valueDeclaration.initializer &&
+          ts.isStringLiteral(symbol.valueDeclaration.initializer)) {
+        return symbol.valueDeclaration.initializer.text;
+      }
+
+      // Check if it's a variable declaration property
+      if (ts.isPropertySignature(symbol.valueDeclaration) ||
+          ts.isMethodSignature(symbol.valueDeclaration)) {
+        const type = checker.getTypeAtLocation(node);
+        if (type && type.isStringLiteral && type.isStringLiteral()) {
+          return type.value;
+        }
+      }
+      // If we haven't returned by now, fall through to the manual fallback below.
     }
-    
-    // Check if it's a variable declaration property
-    if (ts.isPropertySignature(symbol.valueDeclaration) ||
-        ts.isMethodSignature(symbol.valueDeclaration)) {
-      // Try to get the type and see if it's a string literal type
-      const type = checker.getTypeAtLocation(node);
-      if (type.isStringLiteral && type.isStringLiteral()) {
-        return type.value;
+
+    // ---------------------------------------------------------------------
+    // Fallback – manually resolve patterns like:
+    //   const CONST = { KEY: 'value' };
+    //   const CONST = Object.freeze({ KEY: 'value' });
+    // And later accessed as CONST.KEY
+    // ---------------------------------------------------------------------
+
+    if (ts.isIdentifier(node.expression)) {
+      const objIdentifier = node.expression;
+      const initializer = resolveIdentifierToInitializer(checker, objIdentifier, sourceFile);
+
+      if (initializer) {
+        let objectLiteral = null;
+
+        // Direct object literal: const CONST = { KEY: 'value' }
+        if (ts.isObjectLiteralExpression(initializer)) {
+          objectLiteral = initializer;
+        }
+        // Object.freeze pattern: const CONST = Object.freeze({ KEY: 'value' })
+        else if (ts.isCallExpression(initializer)) {
+          const callee = initializer.expression;
+          if (
+            ts.isPropertyAccessExpression(callee) &&
+            ts.isIdentifier(callee.expression) &&
+            callee.expression.escapedText === 'Object' &&
+            callee.name.escapedText === 'freeze' &&
+            initializer.arguments.length > 0 &&
+            ts.isObjectLiteralExpression(initializer.arguments[0])
+          ) {
+            objectLiteral = initializer.arguments[0];
+          }
+        }
+
+        if (objectLiteral) {
+          const propNode = findPropertyByKey(objectLiteral, node.name.escapedText || node.name.text);
+          if (propNode && propNode.initializer && ts.isStringLiteral(propNode.initializer)) {
+            return propNode.initializer.text;
+          }
+        }
       }
     }
-    
+
+    // Final fallback – attempt to use type information (works for imported frozen constants)
+    try {
+      const t = checker.getTypeAtLocation(node);
+      if (t && t.isStringLiteral && typeof t.isStringLiteral === 'function' && t.isStringLiteral()) {
+        return t.value;
+      }
+      if (t && t.flags && (t.flags & ts.TypeFlags.StringLiteral)) {
+        return t.value;
+      }
+    } catch (_) {/* ignore */}
+
     return null;
   } catch (error) {
     return null;

src/analyze/typescript/parser.js

@@ -78,7 +78,23 @@ function findTrackingEvents(sourceFile, checker, filePath, customConfigs = []) {
   const matchesCustomFn = (callNode, fnName) => {
     if (!fnName) return false;
     try {
-      return callNode.expression && callNode.expression.getText() === fnName;
+      const exprText = callNode.expression?.getText?.();
+      if (!exprText) return false;
+
+      // Exact match (existing behaviour)
+      if (exprText === fnName) return true;
+
+      // If fnName is a short identifier (no dot), allow matching trailing property but
+      // only for patterns that include `this.` or `.props.` in the chain to avoid
+      // over-matching generic calls like analytics.track
+      if (!fnName.includes('.')) {
+        if (exprText.endsWith(`.${fnName}`)) {
+          return exprText.startsWith('this.') || exprText.includes('.props.');
+        }
+        return false;
+      }
+
+      return false;
     } catch {
       return false;
     }

tests/fixtures/typescript-react/track-user-event.tsx

@@ -0,0 +1,52 @@
+import React, { useEffect } from 'react';
+
+// Global declarations (simplified for fixture)
+declare function trackUserEvent(eventName: string, properties?: Record<string, any>): void;
+
+declare global {
+  interface PropsWithTracker {
+    trackUserEvent: typeof trackUserEvent;
+  }
+}
+
+export const TELEMETRY_EVENTS = Object.freeze({
+  VIEWED_PAGE: 'ViewedPage',
+  CLICKED_CTA: 'ClickedCTA',
+  VIEWED_DASHBOARD: 'ViewedDashboard'
+});
+
+// -----------------------------------------------------------------------------
+// Functional component – direct identifier usage of trackUserEvent
+// -----------------------------------------------------------------------------
+export const SampleComponent: React.FC = () => {
+  useEffect(() => {
+    // Direct call
+    trackUserEvent(TELEMETRY_EVENTS.VIEWED_PAGE, {
+      path: window.location.pathname
+    });
+  }, []);
+
+  const handleClick = () => {
+    trackUserEvent(TELEMETRY_EVENTS.CLICKED_CTA, { label: 'Start Now' });
+  };
+
+  return <button onClick={handleClick}>Click me</button>;
+};
+
+// -----------------------------------------------------------------------------
+// Class component – this.props.trackUserEvent usage
+// -----------------------------------------------------------------------------
+interface DashboardProps {
+  trackUserEvent: typeof trackUserEvent;
+}
+
+export class Dashboard extends React.Component<DashboardProps> {
+  componentDidMount(): void {
+    // Member expression chain starting with this.props
+    this.props.trackUserEvent(TELEMETRY_EVENTS.VIEWED_DASHBOARD);
+  }
+
+  render() {
+    return <div>Dashboard</div>;
+  }
+}

tests/trackUserEvent.test.js

@@ -0,0 +1,54 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const path = require('path');
+
+const { analyzeTsFile } = require('../src/analyze/typescript');
+const { getProgram } = require('../src/analyze/typescript/parser');
+const { parseCustomFunctionSignature } = require('../src/analyze/utils/customFunctionParser');
+
+// Helper to create minimal program
+function createProgram(filePath) {
+  return getProgram(filePath);
+}
+
+test.describe('trackUserEvent custom tracking function patterns', () => {
+  const fixturesDir = path.join(__dirname, 'fixtures', 'typescript-react');
+  const filePath = path.join(fixturesDir, 'track-user-event.tsx');
+
+  test('should detect trackUserEvent calls in various patterns', () => {
+    const program = createProgram(filePath);
+
+    // Provide two signatures: short name and member expression including this.props
+    const customFunctionSignatures = [
+      parseCustomFunctionSignature('trackUserEvent(EVENT_NAME, PROPERTIES)')
+    ];
+
+    const events = analyzeTsFile(filePath, program, customFunctionSignatures);
+
+    // We expect three events corresponding to the fixture
+    assert.strictEqual(events.length, 3);
+
+    const viewedPage = events.find(e => e.eventName === 'ViewedPage');
+    assert.ok(viewedPage);
+    assert.strictEqual(viewedPage.functionName, 'useEffect()');
+    assert.strictEqual(viewedPage.source, 'custom');
+    assert.deepStrictEqual(viewedPage.properties, {
+      path: { type: 'string' }
+    });
+
+    const clickedCta = events.find(e => e.eventName === 'ClickedCTA');
+    assert.ok(clickedCta);
+    assert.strictEqual(clickedCta.functionName, 'handleClick');
+    assert.strictEqual(clickedCta.source, 'custom');
+    assert.deepStrictEqual(clickedCta.properties, {
+      label: { type: 'string' }
+    });
+
+    const viewedDashboard = events.find(e => e.eventName === 'ViewedDashboard');
+    assert.ok(viewedDashboard);
+    assert.strictEqual(viewedDashboard.functionName, 'componentDidMount');
+    assert.strictEqual(viewedDashboard.source, 'custom');
+    // No properties passed, should be empty object
+    assert.deepStrictEqual(viewedDashboard.properties, {});
+  });
+});