@flisk/analyze-tracking 0.7.6 → 0.8.1

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

@@ -20,6 +20,7 @@ const EXTRACTION_STRATEGIES = {
   googleanalytics: extractGoogleAnalyticsEvent,
   snowplow: extractSnowplowEvent,
   mparticle: extractMparticleEvent,
+  custom: extractCustomEvent,
   default: extractDefaultEvent
 };
 
@@ -27,25 +28,31 @@ const EXTRACTION_STRATEGIES = {
  * Extracts event information from a CallExpression node
  * @param {Object} node - AST CallExpression node
  * @param {string} source - Analytics provider source
+ * @param {Object} constantMap - Collected constant map
+ * @param {Object} customConfig - Parsed custom function configuration
  * @returns {EventData} Extracted event data
  */
-function extractEventData(node, source) {
+function extractEventData(node, source, constantMap = {}, customConfig) {
   const strategy = EXTRACTION_STRATEGIES[source] || EXTRACTION_STRATEGIES.default;
-  return strategy(node);
+  if (source === 'custom') {
+    return strategy(node, constantMap, customConfig);
+  }
+  return strategy(node, constantMap);
 }
 
 /**
  * Extracts Google Analytics event data
  * @param {Object} node - CallExpression node
+ * @param {Object} constantMap - Collected constant map
  * @returns {EventData}
  */
-function extractGoogleAnalyticsEvent(node) {
+function extractGoogleAnalyticsEvent(node, constantMap) {
   if (!node.arguments || node.arguments.length < 3) {
     return { eventName: null, propertiesNode: null };
   }
 
   // gtag('event', 'event_name', { properties })
-  const eventName = getStringValue(node.arguments[1]);
+  const eventName = getStringValue(node.arguments[1], constantMap);
   const propertiesNode = node.arguments[2];
 
   return { eventName, propertiesNode };
@@ -54,9 +61,10 @@ function extractGoogleAnalyticsEvent(node) {
 /**
  * Extracts Snowplow event data
  * @param {Object} node - CallExpression node
+ * @param {Object} constantMap - Collected constant map
  * @returns {EventData}
  */
-function extractSnowplowEvent(node) {
+function extractSnowplowEvent(node, constantMap) {
   if (!node.arguments || node.arguments.length === 0) {
     return { eventName: null, propertiesNode: null };
   }
@@ -70,7 +78,7 @@ function extractSnowplowEvent(node) {
     
     if (structEventArg.type === NODE_TYPES.OBJECT_EXPRESSION) {
       const actionProperty = findPropertyByKey(structEventArg, 'action');
-      const eventName = actionProperty ? getStringValue(actionProperty.value) : null;
+      const eventName = actionProperty ? getStringValue(actionProperty.value, constantMap) : null;
       
       return { eventName, propertiesNode: structEventArg };
     }
@@ -82,15 +90,16 @@ function extractSnowplowEvent(node) {
 /**
  * Extracts mParticle event data
  * @param {Object} node - CallExpression node
+ * @param {Object} constantMap - Collected constant map
  * @returns {EventData}
  */
-function extractMparticleEvent(node) {
+function extractMparticleEvent(node, constantMap) {
   if (!node.arguments || node.arguments.length < 3) {
     return { eventName: null, propertiesNode: null };
   }
 
   // mParticle.logEvent('event_name', mParticle.EventType.Navigation, { properties })
-  const eventName = getStringValue(node.arguments[0]);
+  const eventName = getStringValue(node.arguments[0], constantMap);
   const propertiesNode = node.arguments[2];
 
   return { eventName, propertiesNode };
@@ -99,20 +108,46 @@ function extractMparticleEvent(node) {
 /**
  * Default event extraction for standard providers
  * @param {Object} node - CallExpression node
+ * @param {Object} constantMap - Collected constant map
  * @returns {EventData}
  */
-function extractDefaultEvent(node) {
+function extractDefaultEvent(node, constantMap) {
   if (!node.arguments || node.arguments.length < 2) {
     return { eventName: null, propertiesNode: null };
   }
 
   // provider.track('event_name', { properties })
-  const eventName = getStringValue(node.arguments[0]);
+  const eventName = getStringValue(node.arguments[0], constantMap);
   const propertiesNode = node.arguments[1];
 
   return { eventName, propertiesNode };
 }
 
+/**
+ * Extracts Custom function event data according to signature
+ * @param {Object} node - CallExpression node
+ * @param {Object} constantMap - Collected constant map
+ * @param {Object} customConfig - Parsed custom function configuration
+ * @returns {EventData & {extraArgs:Object}} event data plus extra args map
+ */
+function extractCustomEvent(node, constantMap, customConfig) {
+  const args = node.arguments || [];
+
+  const eventArg = args[customConfig?.eventIndex ?? 0];
+  const propertiesArg = args[customConfig?.propertiesIndex ?? 1];
+
+  const eventName = getStringValue(eventArg, constantMap);
+
+  const extraArgs = {};
+  if (customConfig && customConfig.extraParams) {
+    customConfig.extraParams.forEach(extra => {
+      extraArgs[extra.name] = args[extra.idx];
+    });
+  }
+
+  return { eventName, propertiesNode: propertiesArg, extraArgs };
+}
+
 /**
  * Processes extracted event data into final event object
  * @param {EventData} eventData - Raw event data
@@ -120,9 +155,10 @@ function extractDefaultEvent(node) {
  * @param {string} filePath - File path
  * @param {number} line - Line number
  * @param {string} functionName - Containing function name
+ * @param {Object} customConfig - Parsed custom function configuration
  * @returns {Object|null} Processed event object or null
  */
-function processEventData(eventData, source, filePath, line, functionName) {
+function processEventData(eventData, source, filePath, line, functionName, customConfig) {
   const { eventName, propertiesNode } = eventData;
 
   if (!eventName || !propertiesNode || propertiesNode.type !== NODE_TYPES.OBJECT_EXPRESSION) {
@@ -131,6 +167,24 @@ function processEventData(eventData, source, filePath, line, functionName) {
 
   let properties = extractProperties(propertiesNode);
 
+  // Handle custom extra params
+  if (source === 'custom' && customConfig && eventData.extraArgs) {
+    for (const [paramName, argNode] of Object.entries(eventData.extraArgs)) {
+      if (argNode && argNode.type === NODE_TYPES.OBJECT_EXPRESSION) {
+        // Extract detailed properties from object expression
+        properties[paramName] = {
+          type: 'object',
+          properties: extractProperties(argNode)
+        };
+      } else {
+        // For non-object arguments, use simple type inference
+        properties[paramName] = {
+          type: inferNodeValueType(argNode)
+        };
+      }
+    }
+  }
+
   // Special handling for Snowplow: remove 'action' from properties
   if (source === 'snowplow' && properties.action) {
     delete properties.action;
@@ -149,13 +203,17 @@ function processEventData(eventData, source, filePath, line, functionName) {
 /**
  * Gets string value from an AST node
  * @param {Object} node - AST node
+ * @param {Object} constantMap - Collected constant map
  * @returns {string|null} String value or null
  */
-function getStringValue(node) {
+function getStringValue(node, constantMap = {}) {
   if (!node) return null;
   if (node.type === NODE_TYPES.LITERAL && typeof node.value === 'string') {
     return node.value;
   }
+  if (node.type === NODE_TYPES.MEMBER_EXPRESSION) {
+    return resolveMemberExpressionToString(node, constantMap);
+  }
   return null;
 }
 
@@ -173,6 +231,45 @@ function findPropertyByKey(objectNode, key) {
   );
 }
 
+/**
+ * Infers the type of a value from an AST node (simple heuristic)
+ * @param {Object} node - AST node
+ * @returns {string} inferred type
+ */
+function inferNodeValueType(node) {
+  if (!node) return 'any';
+  switch (node.type) {
+    case NODE_TYPES.LITERAL:
+      return typeof node.value;
+    case NODE_TYPES.OBJECT_EXPRESSION:
+      return 'object';
+    case NODE_TYPES.ARRAY_EXPRESSION:
+      return 'array';
+    default:
+      return 'any';
+  }
+}
+
+// Helper to resolve MemberExpression (CONST.KEY) to string using collected constant map
+function resolveMemberExpressionToString(node, constantMap) {
+  if (!node || node.type !== NODE_TYPES.MEMBER_EXPRESSION) return null;
+  if (node.computed) return null; // Only support dot notation
+
+  const object = node.object;
+  const property = node.property;
+
+  if (object.type !== NODE_TYPES.IDENTIFIER) return null;
+  if (property.type !== NODE_TYPES.IDENTIFIER) return null;
+
+  const objName = object.name;
+  const propName = property.name;
+
+  if (constantMap && constantMap[objName] && typeof constantMap[objName][propName] === 'string') {
+    return constantMap[objName][propName];
+  }
+  return null;
+}
+
 module.exports = {
   extractEventData,
   processEventData

package/src/analyze/javascript/index.js

@@ -11,16 +11,22 @@ const { parseFile, findTrackingEvents, FileReadError, ParseError } = require('./
  * @param {string} [customFunction] - Optional custom function name to detect
  * @returns {Array<Object>} Array of tracking events found in the file
  */
-function analyzeJsFile(filePath, customFunction) {
-  const events = [];
-
+function analyzeJsFile(filePath, customFunctionSignatures = null) {
   try {
-    // Parse the file into an AST
+    // Parse the file into an AST once
     const ast = parseFile(filePath);
 
-    // Find and extract tracking events
-    const foundEvents = findTrackingEvents(ast, filePath, customFunction);
-    events.push(...foundEvents);
+    // Single pass extraction covering built-in + all custom configs
+    const events = findTrackingEvents(ast, filePath, customFunctionSignatures || []);
+
+    // Deduplicate events (by source | eventName | line | functionName)
+    const unique = new Map();
+    for (const evt of events) {
+      const key = `${evt.source}|${evt.eventName}|${evt.line}|${evt.functionName}`;
+      if (!unique.has(key)) unique.set(key, evt);
+    }
+
+    return Array.from(unique.values());
 
   } catch (error) {
     if (error instanceof FileReadError) {
@@ -32,7 +38,7 @@ function analyzeJsFile(filePath, customFunction) {
     }
   }
 
-  return events;
+  return [];
 }
 
 module.exports = { analyzeJsFile };

package/src/analyze/javascript/parser.js

@@ -66,22 +66,147 @@ function parseFile(filePath) {
   }
 }
 
+// ---------------------------------------------
+// Helper – custom function matcher
+// ---------------------------------------------
+
+/**
+ * Determines whether a CallExpression node matches the provided custom function name.
+ * Supports both simple identifiers (e.g. myTrack) and dot-separated members (e.g. Custom.track).
+ * The logic mirrors isCustomFunction from detectors/analytics-source.js but is kept local to avoid
+ * circular dependencies.
+ * @param {Object} node  – CallExpression AST node
+ * @param {string} fnName – Custom function name (could include dots)
+ * @returns {boolean}
+ */
+function nodeMatchesCustomFunction(node, fnName) {
+  if (!fnName || !node.callee) return false;
+
+  const parts = fnName.split('.');
+
+  // Simple identifier case
+  if (parts.length === 1) {
+    return node.callee.type === NODE_TYPES.IDENTIFIER && node.callee.name === fnName;
+  }
+
+  // Member expression chain case
+  if (node.callee.type !== NODE_TYPES.MEMBER_EXPRESSION) {
+    return false;
+  }
+
+  // Walk the chain from the right-most property to the leftmost object
+  let currentNode = node.callee;
+  let idx = parts.length - 1;
+
+  while (currentNode && idx >= 0) {
+    const expected = parts[idx];
+
+    if (currentNode.type === NODE_TYPES.MEMBER_EXPRESSION) {
+      if (
+        currentNode.property.type !== NODE_TYPES.IDENTIFIER ||
+        currentNode.property.name !== expected
+      ) {
+        return false;
+      }
+      currentNode = currentNode.object;
+      idx -= 1;
+    } else if (currentNode.type === NODE_TYPES.IDENTIFIER) {
+      return idx === 0 && currentNode.name === expected;
+    } else {
+      return false;
+    }
+  }
+
+  return false;
+}
+
+// -----------------------------------------------------------------------------
+// Utility – collect constants defined as plain objects or Object.freeze({...})
+// -----------------------------------------------------------------------------
+function collectConstantStringMap(ast) {
+  const map = {};
+
+  walk.simple(ast, {
+    VariableDeclaration(node) {
+      // Only consider const declarations
+      if (node.kind !== 'const') return;
+      node.declarations.forEach(decl => {
+        if (decl.id.type !== NODE_TYPES.IDENTIFIER || !decl.init) return;
+        const name = decl.id.name;
+        let objLiteral = null;
+
+        if (decl.init.type === NODE_TYPES.OBJECT_EXPRESSION) {
+          objLiteral = decl.init;
+        } else if (decl.init.type === NODE_TYPES.CALL_EXPRESSION) {
+          // Check for Object.freeze({...})
+          const callee = decl.init.callee;
+          if (
+            callee &&
+            callee.type === NODE_TYPES.MEMBER_EXPRESSION &&
+            callee.object.type === NODE_TYPES.IDENTIFIER &&
+            callee.object.name === 'Object' &&
+            callee.property.type === NODE_TYPES.IDENTIFIER &&
+            callee.property.name === 'freeze' &&
+            decl.init.arguments.length > 0 &&
+            decl.init.arguments[0].type === NODE_TYPES.OBJECT_EXPRESSION
+          ) {
+            objLiteral = decl.init.arguments[0];
+          }
+        }
+
+        if (objLiteral) {
+          map[name] = {};
+          objLiteral.properties.forEach(prop => {
+            if (!prop.key || !prop.value) return;
+            const keyName = prop.key.name || prop.key.value;
+            if (prop.value.type === NODE_TYPES.LITERAL && typeof prop.value.value === 'string') {
+              map[name][keyName] = prop.value.value;
+            }
+          });
+        }
+      });
+    }
+  });
+
+  return map;
+}
+
 /**
- * Walks the AST and finds analytics tracking calls
- * @param {Object} ast - Parsed AST
- * @param {string} filePath - Path to the file being analyzed
- * @param {string} [customFunction] - Custom function name to detect
- * @returns {Array<Object>} Array of found events
+ * Walk the AST once and find tracking events for built-in providers plus any number of custom
+ * function configurations. This avoids the previous O(n * customConfigs) behaviour.
+ *
+ * @param {Object}  ast                      – Parsed AST of the source file
+ * @param {string}  filePath                 – Absolute/relative path to the source file
+ * @param {Object[]} [customConfigs=[]]      – Array of parsed custom function configurations
+ * @returns {Array<Object>}                  – List of extracted tracking events
  */
-function findTrackingEvents(ast, filePath, customFunction) {
+function findTrackingEvents(ast, filePath, customConfigs = []) {
   const events = [];
 
+  // Collect constant mappings once per file
+  const constantMap = collectConstantStringMap(ast);
+
   walk.ancestor(ast, {
     [NODE_TYPES.CALL_EXPRESSION]: (node, ancestors) => {
       try {
-        const event = extractTrackingEvent(node, ancestors, filePath, customFunction);
-        if (event) {
-          events.push(event);
+        let matchedCustomConfig = null;
+
+        // Attempt to match any custom function first to avoid mis-classifying built-in providers
+        if (Array.isArray(customConfigs) && customConfigs.length > 0) {
+          for (const cfg of customConfigs) {
+            if (cfg && nodeMatchesCustomFunction(node, cfg.functionName)) {
+              matchedCustomConfig = cfg;
+              break;
+            }
+          }
+        }
+
+        if (matchedCustomConfig) {
+          const event = extractTrackingEvent(node, ancestors, filePath, constantMap, matchedCustomConfig);
+          if (event) events.push(event);
+        } else {
+          const event = extractTrackingEvent(node, ancestors, filePath, constantMap, null);
+          if (event) events.push(event);
         }
       } catch (error) {
         console.error(`Error processing node in ${filePath}:`, error.message);
@@ -97,25 +222,19 @@ function findTrackingEvents(ast, filePath, customFunction) {
  * @param {Object} node - CallExpression node
  * @param {Array<Object>} ancestors - Ancestor nodes
  * @param {string} filePath - File path
- * @param {string} [customFunction] - Custom function name
+ * @param {Object} constantMap - Constant string map
+ * @param {Object} [customConfig] - Custom function configuration object
  * @returns {Object|null} Extracted event or null
  */
-function extractTrackingEvent(node, ancestors, filePath, customFunction) {
-  // Detect the analytics source
-  const source = detectAnalyticsSource(node, customFunction);
+function extractTrackingEvent(node, ancestors, filePath, constantMap, customConfig) {
+  const source = detectAnalyticsSource(node, customConfig?.functionName);
   if (source === 'unknown') {
     return null;
   }
-
-  // Extract event data based on the source
-  const eventData = extractEventData(node, source);
-
-  // Get location and context information
+  const eventData = extractEventData(node, source, constantMap, customConfig);
   const line = node.loc.start.line;
   const functionName = findWrappingFunction(node, ancestors);
-
-  // Process the event data into final format
-  return processEventData(eventData, source, filePath, line, functionName);
+  return processEventData(eventData, source, filePath, line, functionName, customConfig);
 }
 
 module.exports = {

package/src/analyze/python/index.js

@@ -40,7 +40,7 @@ async function initPyodide() {
  * libraries, extracting event names, properties, and metadata.
  * 
  * @param {string} filePath - Path to the Python file to analyze
- * @param {string} [customFunction=null] - Name of a custom tracking function to detect
+ * @param {string} [customFunctionSignature=null] - Signature of a custom tracking function to detect
  * @returns {Promise<Array<Object>>} Array of tracking events found in the file
  * @returns {Promise<Array>} Empty array if an error occurs
  * 
@@ -52,48 +52,54 @@ async function initPyodide() {
  * // With custom tracking function
  * const events = await analyzePythonFile('./app.py', 'track_event');
  */
-async function analyzePythonFile(filePath, customFunction = null) {
+async function analyzePythonFile(filePath, customFunctionSignatures = null) {
   // Validate inputs
   if (!filePath || typeof filePath !== 'string') {
     console.error('Invalid file path provided');
     return [];
   }
 
-  try {
-    // Check if file exists before reading
-    if (!fs.existsSync(filePath)) {
-      console.error(`File not found: ${filePath}`);
-      return [];
-    }
+  // Check if file exists before reading
+  if (!fs.existsSync(filePath)) {
+    console.error(`File not found: ${filePath}`);
+    return [];
+  }
 
-    // Read the Python file
+  try {
+    // Read the Python file only once
     const code = fs.readFileSync(filePath, 'utf8');
-    
+
     // Initialize Pyodide if not already done
     const py = await initPyodide();
-    
-    // Load the Python analyzer code
+
+    // Load the Python analyzer code (idempotent – redefining functions is fine)
     const analyzerPath = path.join(__dirname, 'pythonTrackingAnalyzer.py');
     if (!fs.existsSync(analyzerPath)) {
       throw new Error(`Python analyzer not found at: ${analyzerPath}`);
     }
-    
     const analyzerCode = fs.readFileSync(analyzerPath, 'utf8');
-    
-    // Set up Python environment with necessary variables
-    py.globals.set('code', code);
-    py.globals.set('filepath', filePath);
-    py.globals.set('custom_function', customFunction);
-    // Set __name__ to null to prevent execution of main block
+    // Prevent the analyzer from executing any __main__ blocks that expect CLI usage
     py.globals.set('__name__', null);
-    
-    // Load and run the analyzer
     py.runPython(analyzerCode);
-    
-    // Execute the analysis and parse results
-    const result = py.runPython('analyze_python_code(code, filepath, custom_function)');
-    const events = JSON.parse(result);
-    
+
+    // Helper to run analysis with a given custom config (can be null)
+    const runAnalysis = (customConfig) => {
+      py.globals.set('code', code);
+      py.globals.set('filepath', filePath);
+      py.globals.set('custom_config_json', customConfig ? JSON.stringify(customConfig) : null);
+      py.runPython('import json');
+      py.runPython('custom_config = None if custom_config_json == None else json.loads(custom_config_json)');
+      const result = py.runPython('analyze_python_code(code, filepath, custom_config)');
+      return JSON.parse(result);
+    };
+
+    // Prepare config argument (array or null)
+    const configArg = Array.isArray(customFunctionSignatures) && customFunctionSignatures.length > 0
+      ? customFunctionSignatures
+      : null;
+
+    const events = runAnalysis(configArg);
+
     return events;
   } catch (error) {
     // Log detailed error information for debugging