@flisk/analyze-tracking 0.7.4 → 0.7.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flisk/analyze-tracking",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "description": "Analyzes tracking code in a project and generates data schemas",
   "main": "src/index.js",
   "bin": {

package/src/analyze/ruby/detectors.js

@@ -36,7 +36,18 @@ function detectSource(node, customFunction = null) {
   if (node.name === 'track_struct_event') return 'snowplow';
   
   // Custom tracking function
-  if (customFunction && node.name === customFunction) return 'custom';
+  if (customFunction) {
+    // Handle simple function names (e.g., 'customTrackFunction')
+    if (node.name === customFunction) return 'custom';
+    
+    // Handle module-scoped function names (e.g., 'CustomModule.track')
+    if (customFunction.includes('.')) {
+      const [moduleName, methodName] = customFunction.split('.');
+      if (node.receiver && node.receiver.name === moduleName && node.name === methodName) {
+        return 'custom';
+      }
+    }
+  }
 
   return null;
 }

package/src/analyze/ruby/extractors.js

@@ -14,14 +14,17 @@ const { getValueType } = require('./types');
 function extractEventName(node, source) {
   if (source === 'segment' || source === 'rudderstack') {
     // Both Segment and Rudderstack use the same format
-    const params = node.arguments_.arguments_[0].elements;
+    const params = node.arguments_?.arguments_?.[0]?.elements;
+    if (!params || !Array.isArray(params)) {
+      return null;
+    }
     const eventProperty = params.find(param => param?.key?.unescaped?.value === 'event');
     return eventProperty?.value?.unescaped?.value || null;
   }
 
   if (source === 'mixpanel') {
     // Mixpanel Ruby SDK format: tracker.track('distinct_id', 'event_name', {...})
-    const args = node.arguments_.arguments_;
+    const args = node.arguments_?.arguments_;
     if (args && args.length > 1 && args[1]?.unescaped?.value) {
       return args[1].unescaped.value;
     }
@@ -29,8 +32,8 @@ function extractEventName(node, source) {
 
   if (source === 'posthog') {
     // PostHog Ruby SDK format: posthog.capture({distinct_id: '...', event: '...', properties: {...}})
-    const hashArg = node.arguments_.arguments_[0];
-    if (hashArg && hashArg.elements) {
+    const hashArg = node.arguments_?.arguments_?.[0];
+    if (hashArg && hashArg.elements && Array.isArray(hashArg.elements)) {
       const eventProperty = hashArg.elements.find(elem => elem?.key?.unescaped?.value === 'event');
       return eventProperty?.value?.unescaped?.value || null;
     }
@@ -38,14 +41,17 @@ function extractEventName(node, source) {
 
   if (source === 'snowplow') {
     // Snowplow Ruby SDK: tracker.track_struct_event(category: '...', action: '...', ...)
-    const params = node.arguments_.arguments_[0].elements;
+    const params = node.arguments_?.arguments_?.[0]?.elements;
+    if (!params || !Array.isArray(params)) {
+      return null;
+    }
     const actionProperty = params.find(param => param?.key?.unescaped?.value === 'action');
     return actionProperty?.value?.unescaped?.value || null;
   }
   
   if (source === 'custom') {
     // Custom function format: customFunction('event_name', {...})
-    const args = node.arguments_.arguments_;
+    const args = node.arguments_?.arguments_;
     if (args && args.length > 0 && args[0]?.unescaped?.value) {
       return args[0].unescaped.value;
     }
@@ -65,7 +71,10 @@ async function extractProperties(node, source) {
 
   if (source === 'segment' || source === 'rudderstack') {
     // Both Segment and Rudderstack use the same format
-    const params = node.arguments_.arguments_[0].elements;
+    const params = node.arguments_?.arguments_?.[0]?.elements;
+    if (!params || !Array.isArray(params)) {
+      return null;
+    }
     const properties = {};
 
     // Process all top-level fields except 'event'
@@ -108,7 +117,7 @@ async function extractProperties(node, source) {
 
   if (source === 'mixpanel') {
     // Mixpanel Ruby SDK: tracker.track('distinct_id', 'event_name', {properties})
-    const args = node.arguments_.arguments_;
+    const args = node.arguments_?.arguments_;
     const properties = {};
     
     // Add distinct_id as property (even if it's a variable)
@@ -129,10 +138,10 @@ async function extractProperties(node, source) {
 
   if (source === 'posthog') {
     // PostHog Ruby SDK: posthog.capture({distinct_id: '...', event: '...', properties: {...}})
-    const hashArg = node.arguments_.arguments_[0];
+    const hashArg = node.arguments_?.arguments_?.[0];
     const properties = {};
     
-    if (hashArg && hashArg.elements) {
+    if (hashArg && hashArg.elements && Array.isArray(hashArg.elements)) {
       // Extract distinct_id if present
       const distinctIdProperty = hashArg.elements.find(elem => elem?.key?.unescaped?.value === 'distinct_id');
       if (distinctIdProperty?.value) {
@@ -154,7 +163,10 @@ async function extractProperties(node, source) {
 
   if (source === 'snowplow') {
     // Snowplow Ruby SDK: tracker.track_struct_event(category: '...', action: '...', ...)
-    const params = node.arguments_.arguments_[0].elements;
+    const params = node.arguments_?.arguments_?.[0]?.elements;
+    if (!params || !Array.isArray(params)) {
+      return null;
+    }
     const properties = {};
     
     // Extract all struct event parameters except 'action' (which is used as the event name)
@@ -172,7 +184,7 @@ async function extractProperties(node, source) {
   
   if (source === 'custom') {
     // Custom function format: customFunction('event_name', {properties})
-    const args = node.arguments_.arguments_;
+    const args = node.arguments_?.arguments_;
     if (args && args.length > 1 && args[1] instanceof HashNode) {
       return await extractHashProperties(args[1]);
     }

package/src/analyze/ruby/visitor.js

@@ -29,7 +29,16 @@ class TrackingVisitor {
       if (!eventName) return;
 
       const line = getLineNumber(this.code, node.location);
-      const functionName = await findWrappingFunction(node, ancestors);
+      
+      // For module-scoped custom functions, use the custom function name as the functionName
+      // For simple custom functions, use the wrapping function name
+      let functionName;
+      if (source === 'custom' && this.customFunction && this.customFunction.includes('.')) {
+        functionName = this.customFunction;
+      } else {
+        functionName = await findWrappingFunction(node, ancestors);
+      }
+      
       const properties = await extractProperties(node, source);
 
       this.events.push({

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

@@ -48,7 +48,10 @@ function isCustomFunction(node, customFunction) {
     ts.isPropertyAccessExpression(node.expression) ||
     ts.isCallExpression(node.expression) || // For chained calls like getTracker().track()
     ts.isElementAccessExpression(node.expression) || // For array/object access like trackers['analytics'].track()
-    (ts.isPropertyAccessExpression(node.expression?.expression) && ts.isThisExpression(node.expression.expression.expression)); // For class methods like this.analytics.track()
+    (node.expression?.expression && 
+     ts.isPropertyAccessExpression(node.expression.expression) && 
+     node.expression.expression.expression && 
+     ts.isThisExpression(node.expression.expression.expression)); // For class methods like this.analytics.track()
 
   return canBeCustomFunction && node.expression.getText() === customFunction;
 }
@@ -84,8 +87,8 @@ function detectMemberBasedProvider(node) {
     return 'unknown';
   }
 
-  const objectName = node.expression.expression.escapedText;
-  const methodName = node.expression.name.escapedText;
+  const objectName = node.expression.expression?.escapedText;
+  const methodName = node.expression.name?.escapedText;
 
   if (!objectName || !methodName) {
     return 'unknown';

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

@@ -50,7 +50,7 @@ function extractGoogleAnalyticsEvent(node, checker, sourceFile) {
   }
 
   // gtag('event', 'event_name', { properties })
-  const eventName = getStringValue(node.arguments[1]);
+  const eventName = getStringValue(node.arguments[1], checker, sourceFile);
   const propertiesNode = node.arguments[2];
 
   return { eventName, propertiesNode };
@@ -79,7 +79,7 @@ function extractSnowplowEvent(node, checker, sourceFile) {
     const structEventArg = firstArg.arguments[0];
     if (ts.isObjectLiteralExpression(structEventArg)) {
       const actionProperty = findPropertyByKey(structEventArg, 'action');
-      const eventName = actionProperty ? getStringValue(actionProperty.initializer) : null;
+      const eventName = actionProperty ? getStringValue(actionProperty.initializer, checker, sourceFile) : null;
       return { eventName, propertiesNode: structEventArg };
     }
   }
@@ -93,7 +93,7 @@ function extractSnowplowEvent(node, checker, sourceFile) {
       const structEventArg = resolvedNode.arguments[0];
       if (ts.isObjectLiteralExpression(structEventArg)) {
         const actionProperty = findPropertyByKey(structEventArg, 'action');
-        const eventName = actionProperty ? getStringValue(actionProperty.initializer) : null;
+        const eventName = actionProperty ? getStringValue(actionProperty.initializer, checker, sourceFile) : null;
         return { eventName, propertiesNode: structEventArg };
       }
     }
@@ -115,7 +115,7 @@ function extractMparticleEvent(node, checker, sourceFile) {
   }
 
   // mParticle.logEvent('event_name', mParticle.EventType.Navigation, { properties })
-  const eventName = getStringValue(node.arguments[0]);
+  const eventName = getStringValue(node.arguments[0], checker, sourceFile);
   const propertiesNode = node.arguments[2];
 
   return { eventName, propertiesNode };
@@ -134,7 +134,7 @@ function extractDefaultEvent(node, checker, sourceFile) {
   }
 
   // provider.track('event_name', { properties })
-  const eventName = getStringValue(node.arguments[0]);
+  const eventName = getStringValue(node.arguments[0], checker, sourceFile);
   const propertiesNode = node.arguments[1];
 
   return { eventName, propertiesNode };
@@ -197,16 +197,121 @@ function processEventData(eventData, source, filePath, line, functionName, check
 /**
  * Gets string value from a TypeScript AST node
  * @param {Object} node - TypeScript AST node
+ * @param {Object} checker - TypeScript type checker
+ * @param {Object} sourceFile - TypeScript source file
  * @returns {string|null} String value or null
  */
-function getStringValue(node) {
+function getStringValue(node, checker, sourceFile) {
   if (!node) return null;
+  
+  // Handle string literals (existing behavior)
   if (ts.isStringLiteral(node)) {
     return node.text;
   }
+  
+  // Handle property access expressions like TRACKING_EVENTS.ECOMMERCE_PURCHASE
+  if (ts.isPropertyAccessExpression(node)) {
+    return resolvePropertyAccessToString(node, checker, sourceFile);
+  }
+  
+  // Handle identifiers that might reference constants
+  if (ts.isIdentifier(node)) {
+    return resolveIdentifierToString(node, checker, sourceFile);
+  }
+  
   return null;
 }
 
+/**
+ * Resolves a property access expression to its string value
+ * @param {Object} node - PropertyAccessExpression node
+ * @param {Object} checker - TypeScript type checker
+ * @param {Object} sourceFile - TypeScript source file
+ * @returns {string|null} String value or null
+ */
+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;
+    }
+    
+    // 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;
+      }
+    }
+    
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Resolves an identifier to its string value
+ * @param {Object} node - Identifier node
+ * @param {Object} checker - TypeScript type checker
+ * @param {Object} sourceFile - TypeScript source file
+ * @returns {string|null} String value or null
+ */
+function resolveIdentifierToString(node, checker, sourceFile) {
+  try {
+    const symbol = checker.getSymbolAtLocation(node);
+    if (!symbol) {
+      return null;
+    }
+    
+    // First try to resolve through value declaration
+    if (symbol.valueDeclaration) {
+      const declaration = symbol.valueDeclaration;
+      
+      // Handle variable declarations with string literal initializers
+      if (ts.isVariableDeclaration(declaration) && 
+          declaration.initializer &&
+          ts.isStringLiteral(declaration.initializer)) {
+        return declaration.initializer.text;
+      }
+      
+      // Handle const declarations with object literals containing string properties
+      if (ts.isVariableDeclaration(declaration) && 
+          declaration.initializer &&
+          ts.isObjectLiteralExpression(declaration.initializer)) {
+        // This case is handled by property access resolution
+        return null;
+      }
+    }
+    
+    // If value declaration doesn't exist or doesn't help, try type resolution
+    // This handles imported constants that are resolved through TypeScript's type system
+    const type = checker.getTypeOfSymbolAtLocation(symbol, node);
+    if (type && type.isStringLiteral && typeof type.isStringLiteral === 'function' && type.isStringLiteral()) {
+      return type.value;
+    }
+    
+    // Alternative approach for string literal types (different TypeScript versions)
+    if (type && type.flags && (type.flags & ts.TypeFlags.StringLiteral)) {
+      return type.value;
+    }
+    
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+
 /**
  * Finds a property by key in an ObjectLiteralExpression
  * @param {Object} objectNode - ObjectLiteralExpression node

package/src/analyze/typescript/extractors/property-extractor.js

@@ -34,6 +34,13 @@ function extractProperties(checker, node) {
   const properties = {};
 
   for (const prop of node.properties) {
+    // Handle spread assignments like {...object}
+    if (ts.isSpreadAssignment(prop)) {
+      const spreadProperties = extractSpreadProperties(checker, prop);
+      Object.assign(properties, spreadProperties);
+      continue;
+    }
+    
     const key = getPropertyKey(prop);
     if (!key) continue;
 
@@ -350,6 +357,7 @@ function resolveTypeSchema(checker, typeString) {
  * @returns {string|null} Literal type or null
  */
 function getLiteralType(node) {
+  if (!node || typeof node.kind === 'undefined') return null;
   if (ts.isStringLiteral(node)) return 'string';
   if (ts.isNumericLiteral(node)) return 'number';
   if (node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword) return 'boolean';
@@ -370,6 +378,51 @@ function isArrayType(typeString) {
          typeString.startsWith('readonly ');
 }
 
+/**
+ * Extracts properties from a spread assignment
+ * @param {Object} checker - TypeScript type checker
+ * @param {Object} spreadNode - SpreadAssignment node
+ * @returns {Object.<string, PropertySchema>}
+ */
+function extractSpreadProperties(checker, spreadNode) {
+  if (!spreadNode.expression) {
+    return {};
+  }
+  
+  // If the spread is an identifier, resolve it to its declaration
+  if (ts.isIdentifier(spreadNode.expression)) {
+    const symbol = checker.getSymbolAtLocation(spreadNode.expression);
+    if (symbol && symbol.declarations && symbol.declarations.length > 0) {
+      const declaration = symbol.declarations[0];
+      
+      // If it's a variable declaration with an object literal initializer
+      if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
+        if (ts.isObjectLiteralExpression(declaration.initializer)) {
+          // Extract properties directly from the object literal
+          return extractProperties(checker, declaration.initializer);
+        }
+      }
+    }
+    
+    // Fallback to the original identifier schema extraction
+    const identifierSchema = extractIdentifierSchema(checker, spreadNode.expression);
+    return identifierSchema.properties || {};
+  }
+  
+  // If the spread is an object literal, extract its properties
+  if (ts.isObjectLiteralExpression(spreadNode.expression)) {
+    return extractProperties(checker, spreadNode.expression);
+  }
+  
+  // For other expressions, try to get the type and extract properties from it
+  try {
+    const spreadType = checker.getTypeAtLocation(spreadNode.expression);
+    return extractInterfaceProperties(checker, spreadType);
+  } catch (error) {
+    return {};
+  }
+}
+
 /**
  * Extracts properties from a TypeScript interface or type
  * @param {Object} checker - TypeScript type checker

package/src/analyze/typescript/utils/function-finder.js

@@ -93,7 +93,7 @@ function findParentFunctionName(node) {
       parent.initializer &&
       ts.isCallExpression(parent.initializer) &&
       ts.isIdentifier(parent.initializer.expression) &&
-      REACT_HOOKS.has(parent.initializer.expression.escapedText)
+      isReactHookCall(parent.initializer)
     ) {
       return `${parent.initializer.expression.escapedText}(${parent.name.escapedText})`;
     }
@@ -110,6 +110,16 @@ function findParentFunctionName(node) {
     }
   }
 
+  // Property declaration in class: myFunc = () => {}
+  if (ts.isPropertyDeclaration(parent) && parent.name) {
+    if (ts.isIdentifier(parent.name)) {
+      return parent.name.escapedText;
+    }
+    if (ts.isStringLiteral(parent.name)) {
+      return parent.name.text;
+    }
+  }
+
   // Method property in object literal: { myFunc() {} }
   if (ts.isMethodDeclaration(parent) && parent.name) {
     return parent.name.escapedText;
@@ -117,6 +127,7 @@ function findParentFunctionName(node) {
 
   // Binary expression assignment: obj.myFunc = () => {}
   if (ts.isBinaryExpression(parent) &&
+    parent.operatorToken &&
     parent.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
     if (ts.isPropertyAccessExpression(parent.left)) {
       return parent.left.name.escapedText;

package/src/analyze/typescript/utils/type-resolver.js

@@ -144,7 +144,7 @@ function isCustomType(typeString) {
  * @returns {string} Basic type string
  */
 function getBasicTypeOfArrayElement(checker, element) {
-  if (!element) return 'any';
+  if (!element || typeof element.kind === 'undefined') return 'any';
   
   // Check for literal values first
   if (ts.isStringLiteral(element)) {