@flisk/analyze-tracking 0.7.1 → 0.7.3

package/src/analyze/go/trackingDetector.js

@@ -0,0 +1,71 @@
+/**
+ * @fileoverview Analytics tracking detection for Go function calls
+ * @module analyze/go/trackingDetector
+ */
+
+const { ANALYTICS_SOURCES } = require('./constants');
+
+/**
+ * Detect the analytics source from a call or struct literal node
+ * @param {Object} callNode - AST node representing a function call or struct literal
+ * @param {string|null} customFunction - Name of custom tracking function to detect
+ * @returns {string|null} Analytics source name (e.g., 'segment', 'amplitude') or null if not recognized
+ */
+function detectSource(callNode, customFunction) {
+  // Check for struct literals (Segment/Rudderstack/PostHog/Amplitude)
+  if (callNode.tag === 'structlit') {
+    if (callNode.struct) {
+      if (callNode.struct.tag === 'access') {
+        const structType = callNode.struct.member;
+        const namespace = callNode.struct.struct?.value;
+        
+        // Check for specific struct types with their namespaces
+        if (structType === 'Track' && namespace === 'analytics') return ANALYTICS_SOURCES.SEGMENT;
+        if (structType === 'Capture' && namespace === 'posthog') return ANALYTICS_SOURCES.POSTHOG;
+        if (structType === 'Event' && namespace === 'amplitude') return ANALYTICS_SOURCES.AMPLITUDE;
+        
+        // Fallback for struct types without namespace check (backward compatibility)
+        if (structType === 'Track') return ANALYTICS_SOURCES.SEGMENT;
+        if (structType === 'Capture') return ANALYTICS_SOURCES.POSTHOG;
+      }
+    }
+    return null;
+  }
+  
+  // For function calls, check if func property exists
+  if (!callNode.func) return null;
+  
+  // Check for method calls (e.g., client.Track, mp.Track)
+  if (callNode.func.tag === 'access') {
+    const objName = callNode.func.struct?.tag === 'ident' ? callNode.func.struct.value : null;
+    const methodName = callNode.func.member;
+    
+    if (!objName || !methodName) return null;
+    
+    // Check various analytics providers
+    switch (true) {
+      // Mixpanel: mp.Track(ctx, []*mixpanel.Event{...})
+      case objName === 'mp' && methodName === 'Track':
+        return ANALYTICS_SOURCES.MIXPANEL;
+      
+      // Amplitude: client.Track(amplitude.Event{...})
+      case objName === 'client' && methodName === 'Track':
+        return ANALYTICS_SOURCES.AMPLITUDE;
+      
+      // Snowplow: tracker.TrackStructEvent(...)
+      case objName === 'tracker' && methodName === 'TrackStructEvent':
+        return ANALYTICS_SOURCES.SNOWPLOW;
+    }
+  }
+  
+  // Check for custom function calls
+  if (customFunction && callNode.func.tag === 'ident' && callNode.func.value === customFunction) {
+    return ANALYTICS_SOURCES.CUSTOM;
+  }
+  
+  return null;
+}
+
+module.exports = {
+  detectSource
+};

package/src/analyze/go/trackingExtractor.js

@@ -0,0 +1,54 @@
+/**
+ * @fileoverview Tracking event extraction from Go function calls
+ * @module analyze/go/trackingExtractor
+ */
+
+const { ANALYTICS_SOURCES } = require('./constants');
+const { detectSource } = require('./trackingDetector');
+const { extractEventName } = require('./eventExtractor');
+const { extractProperties } = require('./propertyExtractor');
+
+/**
+ * Extract tracking event information from a node
+ * @param {Object} callNode - AST node representing a function call or struct literal
+ * @param {string} filePath - Path to the file being analyzed
+ * @param {string} functionName - Name of the function containing this tracking call
+ * @param {string|null} customFunction - Name of custom tracking function to detect
+ * @param {Object} typeContext - Type information context for variable resolution
+ * @param {string} currentFunction - Current function context for type lookups
+ * @returns {Object|null} Tracking event object with eventName, source, properties, etc., or null if not a tracking call
+ */
+function extractTrackingEvent(callNode, filePath, functionName, customFunction, typeContext, currentFunction) {
+  const source = detectSource(callNode, customFunction);
+  if (!source) return null;
+  
+  const eventName = extractEventName(callNode, source);
+  if (!eventName) return null;
+  
+  const properties = extractProperties(callNode, source, typeContext, currentFunction);
+  
+  // Get line number based on source type
+  let line = 0;
+  if (source === ANALYTICS_SOURCES.SEGMENT || source === ANALYTICS_SOURCES.POSTHOG) {
+    // For Segment and PostHog, we need to get the line number from the struct.struct object
+    if (callNode.tag === 'structlit' && callNode.struct && callNode.struct.struct) {
+      line = callNode.struct.struct.line || 0;
+    }
+  } else {
+    // For other sources, use the line number from the AST node
+    line = callNode.line || 0;
+  }
+  
+  return {
+    eventName,
+    source,
+    properties,
+    filePath,
+    line,
+    functionName
+  };
+}
+
+module.exports = {
+  extractTrackingEvent
+};

package/src/analyze/go/typeContext.js

@@ -0,0 +1,88 @@
+/**
+ * @fileoverview Type context builder for Go AST analysis
+ * @module analyze/go/typeContext
+ */
+
+/**
+ * Build a context of type information from the AST
+ * @param {Array<Object>} ast - Abstract Syntax Tree of the Go file
+ * @returns {Object} Type context object with 'functions' and 'globals' properties
+ * @returns {Object} typeContext.functions - Map of function names to their parameter and local variable types
+ * @returns {Object} typeContext.globals - Map of global variable names to their types and values
+ */
+function buildTypeContext(ast) {
+  const context = {
+    functions: {},
+    globals: {}
+  };
+  
+  for (const node of ast) {
+    if (node.tag === 'func') {
+      // Store function parameter types
+      context.functions[node.name] = {
+        params: {},
+        locals: {}
+      };
+      
+      if (node.args) {
+        for (const arg of node.args) {
+          if (arg.name && arg.type) {
+            context.functions[node.name].params[arg.name] = { type: arg.type };
+          }
+        }
+      }
+      
+      // Scan function body for local variable declarations
+      if (node.body) {
+        scanForDeclarations(node.body, context.functions[node.name].locals);
+      }
+    } else if (node.tag === 'declare') {
+      // Global variable declarations
+      if (node.names && node.names.length > 0 && node.type) {
+        for (const name of node.names) {
+          context.globals[name] = { type: node.type, value: node.value };
+        }
+      }
+    }
+  }
+  
+  return context;
+}
+
+/**
+ * Scan statements for variable declarations
+ * @param {Array<Object>} body - Array of AST statement nodes to scan
+ * @param {Object} locals - Object to store local variable declarations (modified in place)
+ */
+function scanForDeclarations(body, locals) {
+  for (const stmt of body) {
+    if (stmt.tag === 'declare') {
+      if (stmt.names && stmt.type) {
+        for (const name of stmt.names) {
+          locals[name] = { type: stmt.type, value: stmt.value };
+        }
+      }
+    } else if (stmt.tag === 'if' && stmt.body) {
+      scanForDeclarations(stmt.body, locals);
+    } else if (stmt.tag === 'elseif' && stmt.body) {
+      scanForDeclarations(stmt.body, locals);
+    } else if (stmt.tag === 'else' && stmt.body) {
+      scanForDeclarations(stmt.body, locals);
+    } else if (stmt.tag === 'for' && stmt.body) {
+      scanForDeclarations(stmt.body, locals);
+    } else if (stmt.tag === 'foreach' && stmt.body) {
+      scanForDeclarations(stmt.body, locals);
+    } else if (stmt.tag === 'switch' && stmt.cases) {
+      for (const caseNode of stmt.cases) {
+        if (caseNode.body) {
+          scanForDeclarations(caseNode.body, locals);
+        }
+      }
+    }
+  }
+}
+
+module.exports = {
+  buildTypeContext,
+  scanForDeclarations
+};

package/src/analyze/go/utils.js

@@ -0,0 +1,215 @@
+/**
+ * @fileoverview Utility functions for Go AST analysis and type extraction
+ * @module analyze/go/utils
+ */
+
+/**
+ * Extract string value from various node types
+ * @param {Object} node - AST node that may contain a string value
+ * @returns {string|null} Extracted string value without quotes, or null if not found
+ */
+function extractStringValue(node) {
+  if (!node) return null;
+  
+  // Handle direct string literals
+  if (node.tag === 'string') {
+    // Remove quotes from the value
+    return node.value.slice(1, -1);
+  }
+  
+  // Handle expressions that might contain a string
+  if (node.tag === 'expr' && node.body && node.body.length > 0) {
+    // Look for string literals in the expression body
+    for (const item of node.body) {
+      if (item.tag === 'string') {
+        return item.value.slice(1, -1);
+      }
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Find a struct literal in an expression
+ * @param {Object} expr - AST expression node to search
+ * @returns {Object|null} Struct literal AST node or null if not found
+ */
+function findStructLiteral(expr) {
+  if (!expr) return null;
+  
+  if (expr.tag === 'structlit') {
+    return expr;
+  }
+  
+  if (expr.tag === 'expr' && expr.body) {
+    for (const item of expr.body) {
+      if (item.tag === 'structlit') {
+        return item;
+      }
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Find a field in a struct by name
+ * @param {Object} structlit - Struct literal AST node
+ * @param {string} fieldName - Name of the field to find
+ * @returns {Object|null} Field AST node or null if not found
+ */
+function findStructField(structlit, fieldName) {
+  if (!structlit.fields) return null;
+  
+  for (const field of structlit.fields) {
+    const name = extractFieldName(field);
+    if (name === fieldName) {
+      return field;
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Extract field name from a struct field
+ * @param {Object} field - Struct field AST node
+ * @returns {string|null} Field name or null if not found
+ */
+function extractFieldName(field) {
+  if (field.name) {
+    return field.name;
+  }
+  
+  if (field.value && field.value.tag === 'expr' && field.value.body) {
+    // Look for pattern: fieldName: value
+    const body = field.value.body;
+    if (body.length >= 3 && 
+        body[0].tag === 'ident' && 
+        body[1].tag === 'op' && 
+        body[1].value === ':') {
+      return body[0].value;
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Map Go types to schema types
+ * @param {Object} goType - Go type AST node
+ * @returns {Object} Schema type object with 'type' property and optionally 'items' or 'properties'
+ */
+function mapGoTypeToSchemaType(goType) {
+  if (!goType) return { type: 'any' };
+  
+  // Handle case where goType might be an object with a type property
+  if (goType.type) {
+    goType = goType.type;
+  }
+  
+  // Handle simple types
+  if (goType.tag === 'string') return { type: 'string' };
+  if (goType.tag === 'bool') return { type: 'boolean' };
+  if (goType.tag === 'int' || goType.tag === 'int8' || goType.tag === 'int16' || 
+      goType.tag === 'int32' || goType.tag === 'int64' || goType.tag === 'uint' ||
+      goType.tag === 'uint8' || goType.tag === 'uint16' || goType.tag === 'uint32' ||
+      goType.tag === 'uint64' || goType.tag === 'float32' || goType.tag === 'float64' ||
+      goType.tag === 'byte' || goType.tag === 'rune') {
+    return { type: 'number' };
+  }
+  
+  // Handle array types
+  if (goType.tag === 'array') {
+    const itemType = mapGoTypeToSchemaType(goType.item);
+    return {
+      type: 'array',
+      items: itemType
+    };
+  }
+  
+  // Handle slice types (arrays without fixed size)
+  if (goType.tag === 'array' && !goType.size) {
+    const itemType = mapGoTypeToSchemaType(goType.item);
+    return {
+      type: 'array',
+      items: itemType
+    };
+  }
+  
+  // Handle map types
+  if (goType.tag === 'map') {
+    return {
+      type: 'object',
+      properties: {}
+    };
+  }
+  
+  // Handle pointer types by dereferencing
+  if (goType.tag === 'ptr') {
+    return mapGoTypeToSchemaType(goType.item);
+  }
+  
+  // Default to any for complex or unknown types
+  return { type: 'any' };
+}
+
+/**
+ * Extract Snowplow values from sphelp.NewString/NewFloat64
+ * @param {Object} expr - Expression containing Snowplow helper function call
+ * @returns {string|number|null} Extracted value or null if not found
+ */
+function extractSnowplowValue(expr) {
+  if (!expr) return null;
+  
+  // Direct value
+  if (expr.tag === 'string') {
+    return expr.value.slice(1, -1);
+  }
+  if (expr.tag === 'number') {
+    return parseFloat(expr.value);
+  }
+  
+  // Look for sphelp.NewString("value") or sphelp.NewFloat64(value)
+  if (expr.tag === 'expr' && expr.body) {
+    for (const item of expr.body) {
+      if (item.tag === 'call' && item.func && item.func.tag === 'access') {
+        if (item.func.member === 'NewString' && item.args && item.args.length > 0) {
+          return extractStringValue(item.args[0]);
+        }
+        if (item.func.member === 'NewFloat64' && item.args && item.args.length > 0) {
+          const numExpr = item.args[0];
+          if (numExpr.tag === 'number') {
+            return parseFloat(numExpr.value);
+          }
+          if (numExpr.tag === 'expr' && numExpr.body && numExpr.body[0] && numExpr.body[0].tag === 'number') {
+            return parseFloat(numExpr.body[0].value);
+          }
+        }
+      }
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Resolves a variable to its value by looking it up in the type context
+ * @param {string} varName - The variable name to resolve
+ * @param {Object} typeContext - The type context containing variable types
+ * @param {string} currentFunction - The current function scope
+ * @returns {Object|null} The resolved value or null
+ */
+function resolveVariable(varName, typeContext, currentFunction) {
+  // ... existing code ...
+}
+
+module.exports = {
+  extractStringValue,
+  findStructLiteral,
+  findStructField,
+  extractFieldName,
+  mapGoTypeToSchemaType,
+  extractSnowplowValue
+};

package/src/analyze/index.js

@@ -1,11 +1,16 @@
+/**
+ * @fileoverview Directory analyzer for detecting analytics tracking across multiple programming languages
+ * @module analyze-tracking/analyze
+ */
+
 const path = require('path');
 const ts = require('typescript');
-const { getAllFiles } = require('../fileProcessor');
-const { analyzeJsFile } = require('./analyzeJsFile');
-const { analyzeTsFile } = require('./analyzeTsFile');
-const { analyzePythonFile } = require('./analyzePythonFile');
-const { analyzeRubyFile } = require('./analyzeRubyFile');
-const { analyzeGoFile } = require('./analyzeGoFile');
+const { getAllFiles } = require('../utils/fileProcessor');
+const { analyzeJsFile } = require('./javascript');
+const { analyzeTsFile } = require('./typescript');
+const { analyzePythonFile } = require('./python');
+const { analyzeRubyFile } = require('./ruby');
+const { analyzeGoFile } = require('./go');
 
 async function analyzeDirectory(dirPath, customFunction) {
   const allEvents = {};
@@ -37,7 +42,6 @@ async function analyzeDirectory(dirPath, customFunction) {
     } else if (isGoFile) {
       events = await analyzeGoFile(file, customFunction);
     } else {
-      console.info(`Skipping file ${file} because it is not a supported file type`);
       continue;
     }
 

package/src/analyze/javascript/constants.js

@@ -0,0 +1,115 @@
+/**
+ * @fileoverview Constants and configurations for analytics tracking providers
+ * @module analyze/javascript/constants
+ */
+
+/**
+ * Analytics provider configurations
+ * @typedef {Object} ProviderConfig
+ * @property {string} name - Provider display name
+ * @property {string} objectName - Object name in JavaScript
+ * @property {string} methodName - Method name for tracking
+ * @property {string} type - Type of detection (member|function)
+ */
+
+/**
+ * Supported analytics providers and their detection patterns
+ * @type {Object.<string, ProviderConfig>}
+ */
+const ANALYTICS_PROVIDERS = {
+  SEGMENT: {
+    name: 'segment',
+    objectName: 'analytics',
+    methodName: 'track',
+    type: 'member'
+  },
+  MIXPANEL: {
+    name: 'mixpanel',
+    objectName: 'mixpanel',
+    methodName: 'track',
+    type: 'member'
+  },
+  AMPLITUDE: {
+    name: 'amplitude',
+    objectName: 'amplitude',
+    methodName: 'track',
+    type: 'member'
+  },
+  RUDDERSTACK: {
+    name: 'rudderstack',
+    objectName: 'rudderanalytics',
+    methodName: 'track',
+    type: 'member'
+  },
+  MPARTICLE: {
+    name: 'mparticle',
+    objectNames: ['mParticle', 'mparticle'],
+    methodName: 'logEvent',
+    type: 'member'
+  },
+  POSTHOG: {
+    name: 'posthog',
+    objectName: 'posthog',
+    methodName: 'capture',
+    type: 'member'
+  },
+  PENDO: {
+    name: 'pendo',
+    objectName: 'pendo',
+    methodName: 'track',
+    type: 'member'
+  },
+  HEAP: {
+    name: 'heap',
+    objectName: 'heap',
+    methodName: 'track',
+    type: 'member'
+  },
+  SNOWPLOW: {
+    name: 'snowplow',
+    objectName: 'tracker',
+    methodName: 'track',
+    type: 'member'
+  },
+  GOOGLE_ANALYTICS: {
+    name: 'googleanalytics',
+    functionName: 'gtag',
+    type: 'function'
+  }
+};
+
+/**
+ * Parser options for Acorn
+ * @type {Object}
+ */
+const PARSER_OPTIONS = {
+  ecmaVersion: 'latest',
+  sourceType: 'module',
+  locations: true
+};
+
+/**
+ * AST node types
+ * @enum {string}
+ */
+const NODE_TYPES = {
+  CALL_EXPRESSION: 'CallExpression',
+  MEMBER_EXPRESSION: 'MemberExpression',
+  IDENTIFIER: 'Identifier',
+  OBJECT_EXPRESSION: 'ObjectExpression',
+  ARRAY_EXPRESSION: 'ArrayExpression',
+  LITERAL: 'Literal',
+  ARROW_FUNCTION: 'ArrowFunctionExpression',
+  FUNCTION_EXPRESSION: 'FunctionExpression',
+  FUNCTION_DECLARATION: 'FunctionDeclaration',
+  METHOD_DEFINITION: 'MethodDefinition',
+  VARIABLE_DECLARATOR: 'VariableDeclarator',
+  EXPORT_NAMED: 'ExportNamedDeclaration',
+  PROPERTY: 'Property'
+};
+
+module.exports = {
+  ANALYTICS_PROVIDERS,
+  PARSER_OPTIONS,
+  NODE_TYPES
+};

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

@@ -0,0 +1,119 @@
+/**
+ * @fileoverview Analytics source detection module
+ * @module analyze/javascript/detectors/analytics-source
+ */
+
+const { ANALYTICS_PROVIDERS, NODE_TYPES } = require('../constants');
+
+/**
+ * Detects the analytics provider from a CallExpression node
+ * @param {Object} node - AST CallExpression node
+ * @param {string} [customFunction] - Custom function name to detect
+ * @returns {string} The detected analytics source or 'unknown'
+ */
+function detectAnalyticsSource(node, customFunction) {
+  if (!node.callee) {
+    return 'unknown';
+  }
+
+  // Check for custom function first
+  if (customFunction && isCustomFunction(node, customFunction)) {
+    return 'custom';
+  }
+
+  // Check for function-based providers (e.g., gtag)
+  const functionSource = detectFunctionBasedProvider(node);
+  if (functionSource !== 'unknown') {
+    return functionSource;
+  }
+
+  // Check for member-based providers (e.g., analytics.track)
+  const memberSource = detectMemberBasedProvider(node);
+  if (memberSource !== 'unknown') {
+    return memberSource;
+  }
+
+  return 'unknown';
+}
+
+/**
+ * Checks if the node is a custom function call
+ * @param {Object} node - AST CallExpression node
+ * @param {string} customFunction - Custom function name
+ * @returns {boolean}
+ */
+function isCustomFunction(node, customFunction) {
+  return node.callee.type === NODE_TYPES.IDENTIFIER && 
+         node.callee.name === customFunction;
+}
+
+/**
+ * Detects function-based analytics providers
+ * @param {Object} node - AST CallExpression node
+ * @returns {string} Provider name or 'unknown'
+ */
+function detectFunctionBasedProvider(node) {
+  if (node.callee.type !== NODE_TYPES.IDENTIFIER) {
+    return 'unknown';
+  }
+
+  const functionName = node.callee.name;
+  
+  for (const provider of Object.values(ANALYTICS_PROVIDERS)) {
+    if (provider.type === 'function' && provider.functionName === functionName) {
+      return provider.name;
+    }
+  }
+
+  return 'unknown';
+}
+
+/**
+ * Detects member expression-based analytics providers
+ * @param {Object} node - AST CallExpression node
+ * @returns {string} Provider name or 'unknown'
+ */
+function detectMemberBasedProvider(node) {
+  if (node.callee.type !== NODE_TYPES.MEMBER_EXPRESSION) {
+    return 'unknown';
+  }
+
+  const objectName = node.callee.object.name;
+  const methodName = node.callee.property.name;
+
+  if (!objectName || !methodName) {
+    return 'unknown';
+  }
+
+  for (const provider of Object.values(ANALYTICS_PROVIDERS)) {
+    if (provider.type === 'member' && matchesMemberProvider(provider, objectName, methodName)) {
+      return provider.name;
+    }
+  }
+
+  return 'unknown';
+}
+
+/**
+ * Checks if object and method names match a provider configuration
+ * @param {Object} provider - Provider configuration
+ * @param {string} objectName - Object name from AST
+ * @param {string} methodName - Method name from AST
+ * @returns {boolean}
+ */
+function matchesMemberProvider(provider, objectName, methodName) {
+  if (provider.methodName !== methodName) {
+    return false;
+  }
+
+  // Handle providers with multiple possible object names (e.g., mParticle/mparticle)
+  if (provider.objectNames) {
+    return provider.objectNames.includes(objectName);
+  }
+
+  return provider.objectName === objectName;
+}
+
+module.exports = {
+  detectAnalyticsSource
+};