@flisk/analyze-tracking 0.8.6 → 0.8.8

package/README.md

@@ -101,18 +101,19 @@ See [schema.json](schema.json) for a JSON Schema of the output.
 
 | Library | JavaScript/TypeScript | Python | Ruby | Go |
 |---------|:---------------------:|:------:|:----:|:--:|
-| Google Analytics  | ✅ | ❌ | ❌ | ❌ |
-| Segment           | ✅ | ✅ | ✅ | ✅ |
-| Mixpanel          | ✅ | ✅ | ✅ | ✅ |
-| Amplitude         | ✅ | ✅ | ❌ | ✅ |
-| Rudderstack       | ✅ | ✅ | ✳️ | ✳️ |
-| mParticle         | ✅ | ❌ | ❌ | ❌ |
-| PostHog           | ✅ | ✅ | ✅ | ✅ |
-| Pendo             | ✅ | ❌ | ❌ | ❌ |
-| Heap              | ✅ | ❌ | ❌ | ❌ |
-| Snowplow          | ✅ | ✅ | ✅ | ✅ |
-| Datadog RUM       | ✅ | ❌ | ❌ | ❌ |
-| Custom Function   | ✅ | ✅ | ✅ | ✅ |
+| Google Analytics   | ✅ | ❌ | ❌ | ❌ |
+| Google Tag Manager | ✅ | ❌ | ❌ | ❌ |
+| Segment            | ✅ | ✅ | ✅ | ✅ |
+| Mixpanel           | ✅ | ✅ | ✅ | ✅ |
+| Amplitude          | ✅ | ✅ | ❌ | ✅ |
+| Rudderstack        | ✅ | ✅ | ✳️ | ✳️ |
+| mParticle          | ✅ | ❌ | ❌ | ❌ |
+| PostHog            | ✅ | ✅ | ✅ | ✅ |
+| Pendo              | ✅ | ❌ | ❌ | ❌ |
+| Heap               | ✅ | ❌ | ❌ | ❌ |
+| Snowplow           | ✅ | ✅ | ✅ | ✅ |
+| Datadog RUM        | ✅ | ❌ | ❌ | ❌ |
+| Custom Function    | ✅ | ✅ | ✅ | ✅ |
 
 ✳️ Rudderstack's SDKs often use the same format as Segment, so Rudderstack events may be detected as Segment events.
 
@@ -130,6 +131,24 @@ See [schema.json](schema.json) for a JSON Schema of the output.
   ```
 </details>
 
+<details>
+  <summary>Google Tag Manager</summary>
+
+  **JavaScript/TypeScript**
+  ```js
+  dataLayer.push({
+    event: '<event_name>',
+    '<property_name>': '<property_value>'
+  });
+
+  // Or via window
+  window.dataLayer.push({
+    event: '<event_name>',
+    '<property_name>': '<property_value>'
+  });
+  ```
+</details>
+
 <details>
   <summary>Segment</summary>
 

package/package.json

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

package/schema.json

@@ -68,6 +68,7 @@
                       "heap",
                       "snowplow",
                       "datadog",
+                      "gtm",
                       "custom",
                       "unknown"
                     ],

package/src/analyze/javascript/constants.js

@@ -81,6 +81,12 @@ const ANALYTICS_PROVIDERS = {
     objectNames: ['datadogRum', 'DD_RUM'],
     methodName: 'addAction',
     type: 'member'
+  },
+  GOOGLE_TAG_MANAGER: {
+    name: 'gtm',
+    objectNames: ['dataLayer'],
+    methodName: 'push',
+    type: 'member'
   }
 };
 

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

@@ -45,20 +45,23 @@ function detectAnalyticsSource(node, customFunction) {
 function isCustomFunction(node, customFunction) {
   if (!customFunction) return false;
 
-  // Support dot-separated names like "CustomModule.track"
-  const parts = customFunction.split('.');
+  // Support dot-separated names like "CustomModule.track" and chained calls like "getTrackingService().track"
+  // Normalize each segment by stripping trailing parentheses
+  const parts = customFunction.split('.').map(p => p.replace(/\(\s*\)$/, ''));
 
   // Simple identifier (no dot)
   if (parts.length === 1) {
-    return node.callee.type === NODE_TYPES.IDENTIFIER && node.callee.name === customFunction;
+    return node.callee.type === NODE_TYPES.IDENTIFIER && node.callee.name === parts[0];
   }
 
-  // For dot-separated names, the callee should be a MemberExpression chain.
-  if (node.callee.type !== NODE_TYPES.MEMBER_EXPRESSION) {
+  // For dot-separated names, the callee should be a MemberExpression chain,
+  // but we also allow CallExpression in the chain (e.g., getService().track)
+  const callee = node.callee;
+  if (callee.type !== NODE_TYPES.MEMBER_EXPRESSION && callee.type !== NODE_TYPES.CALL_EXPRESSION) {
     return false;
   }
 
-  return matchesMemberChain(node.callee, parts);
+  return matchesMemberChain(callee, parts);
 }
 
 /**
@@ -75,9 +78,8 @@ function matchesMemberChain(memberExpr, parts) {
   while (currentNode && idx >= 0) {
     const expectedPart = parts[idx];
 
-    // property should match current expectedPart
     if (currentNode.type === NODE_TYPES.MEMBER_EXPRESSION) {
-      // Ensure property is Identifier and matches
+      // Ensure property is Identifier and matches the expected part
       if (
         currentNode.property.type !== NODE_TYPES.IDENTIFIER ||
         currentNode.property.name !== expectedPart
@@ -85,16 +87,25 @@ function matchesMemberChain(memberExpr, parts) {
         return false;
       }
 
-      // Move to the object of the MemberExpression
+      // Move to the object (which could itself be a MemberExpression, Identifier, or CallExpression)
       currentNode = currentNode.object;
       idx -= 1;
-    } else if (currentNode.type === NODE_TYPES.IDENTIFIER) {
-      // We reached the leftmost Identifier; it should match the first part
+      continue;
+    }
+
+    // If we encounter a CallExpression in the chain (e.g., getService().track),
+    // step into its callee without consuming an expected part.
+    if (currentNode.type === NODE_TYPES.CALL_EXPRESSION) {
+      currentNode = currentNode.callee;
+      continue;
+    }
+
+    if (currentNode.type === NODE_TYPES.IDENTIFIER) {
       return idx === 0 && currentNode.name === expectedPart;
-    } else {
-      // Unexpected node type (e.g., ThisExpression, CallExpression, etc.)
-      return false;
     }
+
+    // Unexpected node type (e.g., ThisExpression, Literal, etc.)
+    return false;
   }
 
   return false;

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

@@ -20,6 +20,7 @@ const EXTRACTION_STRATEGIES = {
   googleanalytics: extractGoogleAnalyticsEvent,
   snowplow: extractSnowplowEvent,
   mparticle: extractMparticleEvent,
+  gtm: extractGTMEvent,
   custom: extractCustomEvent,
   default: extractDefaultEvent
 };
@@ -105,6 +106,43 @@ function extractMparticleEvent(node, constantMap) {
   return { eventName, propertiesNode };
 }
 
+/**
+ * Extracts Google Tag Manager event data
+ * @param {Object} node - CallExpression node
+ * @param {Object} constantMap - Collected constant map
+ * @returns {EventData}
+ */
+function extractGTMEvent(node, constantMap) {
+  if (!node.arguments || node.arguments.length === 0) {
+    return { eventName: null, propertiesNode: null };
+  }
+
+  // dataLayer.push({ event: 'event_name', property1: 'value1', property2: 'value2' })
+  const firstArg = node.arguments[0];
+  
+  if (firstArg.type !== NODE_TYPES.OBJECT_EXPRESSION) {
+    return { eventName: null, propertiesNode: null };
+  }
+
+  // Find the 'event' property
+  const eventProperty = findPropertyByKey(firstArg, 'event');
+  if (!eventProperty) {
+    return { eventName: null, propertiesNode: null };
+  }
+
+  const eventName = getStringValue(eventProperty.value, constantMap);
+  
+  // Create a modified properties node without the 'event' property
+  const modifiedPropertiesNode = {
+    ...firstArg,
+    properties: firstArg.properties.filter(prop => 
+      prop.key && (prop.key.name !== 'event' && prop.key.value !== 'event')
+    )
+  };
+
+  return { eventName, propertiesNode: modifiedPropertiesNode };
+}
+
 /**
  * Default event extraction for standard providers
  * @param {Object} node - CallExpression node
@@ -219,7 +257,11 @@ function getStringValue(node, constantMap = {}) {
     return node.value;
   }
   if (node.type === NODE_TYPES.MEMBER_EXPRESSION) {
-    return resolveMemberExpressionToString(node, constantMap);
+    const resolved = resolveMemberExpressionToString(node, constantMap);
+    if (resolved) return resolved;
+    // Fallback: return a dotted path for member expressions when we cannot
+    // resolve to a literal (e.g., imported constants like TELEMETRY_EVENTS.X)
+    return memberExpressionToPath(node);
   }
   return null;
 }
@@ -277,6 +319,25 @@ function resolveMemberExpressionToString(node, constantMap) {
   return null;
 }
 
+// Build a dotted path string for a MemberExpression (e.g., OBJ.KEY.SUBKEY)
+function memberExpressionToPath(node) {
+  if (!node || node.type !== NODE_TYPES.MEMBER_EXPRESSION) return null;
+  const parts = [];
+  let current = node;
+  while (current && current.type === NODE_TYPES.MEMBER_EXPRESSION && !current.computed) {
+    if (current.property && current.property.type === NODE_TYPES.IDENTIFIER) {
+      parts.unshift(current.property.name);
+    } else if (current.property && current.property.type === NODE_TYPES.LITERAL) {
+      parts.unshift(String(current.property.value));
+    }
+    current = current.object;
+  }
+  if (current && current.type === NODE_TYPES.IDENTIFIER) {
+    parts.unshift(current.name);
+  }
+  return parts.length ? parts.join('.') : null;
+}
+
 module.exports = {
   extractEventData,
   processEventData

package/src/analyze/javascript/parser.js

@@ -12,6 +12,7 @@ const { PARSER_OPTIONS, NODE_TYPES } = require('./constants');
 const { detectAnalyticsSource } = require('./detectors');
 const { extractEventData, processEventData } = require('./extractors');
 const { findWrappingFunction } = require('./utils/function-finder');
+const { collectImportedConstantStringMap } = require('./utils/import-resolver');
 
 // Extend walker to support JSX
 extend(walk.base);
@@ -82,19 +83,15 @@ function parseFile(filePath) {
 function nodeMatchesCustomFunction(node, fnName) {
   if (!fnName || !node.callee) return false;
 
-  const parts = fnName.split('.');
+  // Support chained calls in function name by stripping trailing parens from each segment
+  const parts = fnName.split('.').map(p => p.replace(/\(\s*\)$/, ''));
 
   // Simple identifier case
   if (parts.length === 1) {
-    return node.callee.type === NODE_TYPES.IDENTIFIER && node.callee.name === fnName;
+    return node.callee.type === NODE_TYPES.IDENTIFIER && node.callee.name === parts[0];
   }
 
-  // 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
+  // Allow MemberExpression and CallExpression within the chain (e.g., getService().track)
   let currentNode = node.callee;
   let idx = parts.length - 1;
 
@@ -108,13 +105,23 @@ function nodeMatchesCustomFunction(node, fnName) {
       ) {
         return false;
       }
+      // step to the object; do not decrement idx for call expressions yet
       currentNode = currentNode.object;
       idx -= 1;
-    } else if (currentNode.type === NODE_TYPES.IDENTIFIER) {
+      continue;
+    }
+
+    if (currentNode.type === NODE_TYPES.CALL_EXPRESSION) {
+      // descend into the callee of the call without consuming a part
+      currentNode = currentNode.callee;
+      continue;
+    }
+
+    if (currentNode.type === NODE_TYPES.IDENTIFIER) {
       return idx === 0 && currentNode.name === expected;
-    } else {
-      return false;
     }
+
+    return false;
   }
 
   return false;
@@ -183,8 +190,11 @@ function collectConstantStringMap(ast) {
 function findTrackingEvents(ast, filePath, customConfigs = []) {
   const events = [];
 
-  // Collect constant mappings once per file
-  const constantMap = collectConstantStringMap(ast);
+  // Collect constant mappings once per file (locals + imported)
+  const constantMap = {
+    ...collectConstantStringMap(ast),
+    ...collectImportedConstantStringMap(filePath, ast)
+  };
 
   walk.ancestor(ast, {
     [NODE_TYPES.CALL_EXPRESSION]: (node, ancestors) => {

package/src/analyze/javascript/utils/import-resolver.js

@@ -0,0 +1,233 @@
+const fs = require('fs');
+const path = require('path');
+const ts = require('typescript');
+const acorn = require('acorn');
+const jsx = require('acorn-jsx');
+const { PARSER_OPTIONS, NODE_TYPES } = require('../constants');
+
+const JS_EXTENSIONS = ['.js', '.mjs', '.cjs', '.jsx'];
+const TS_EXTENSIONS = ['.ts', '.tsx'];
+const ALL_EXTENSIONS = [...JS_EXTENSIONS, ...TS_EXTENSIONS, '.json'];
+
+function tryFileWithExtensions(basePath) {
+  for (const ext of ALL_EXTENSIONS) {
+    const full = basePath + ext;
+    if (fs.existsSync(full) && fs.statSync(full).isFile()) return full;
+  }
+  // index.* inside directory
+  if (fs.existsSync(basePath) && fs.statSync(basePath).isDirectory()) {
+    for (const ext of ALL_EXTENSIONS) {
+      const idx = path.join(basePath, 'index' + ext);
+      if (fs.existsSync(idx) && fs.statSync(idx).isFile()) return idx;
+    }
+  }
+  return null;
+}
+
+function resolveModulePath(specifier, fromDir) {
+  // Relative or absolute
+  if (specifier.startsWith('.') || specifier.startsWith('/')) {
+    const abs = path.resolve(fromDir, specifier);
+    const direct = tryFileWithExtensions(abs);
+    if (direct) return direct;
+  } else {
+    // Bare or aliased import – search upwards for a matching folder for first segment
+    const parts = specifier.split('/');
+    let current = fromDir;
+    while (true) {
+      const candidateRoot = path.join(current, parts[0]);
+      if (fs.existsSync(candidateRoot) && fs.statSync(candidateRoot).isDirectory()) {
+        const fullBase = path.join(current, specifier);
+        const resolved = tryFileWithExtensions(fullBase);
+        if (resolved) return resolved;
+      }
+      const parent = path.dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+  }
+  return null;
+}
+
+// Extracts exported constant object maps from a JS/TS file.
+// Returns: { ExportName: { KEY: 'value', ... }, ... }
+function extractExportedConstStringMap(filePath) {
+  const code = fs.readFileSync(filePath, 'utf8');
+  const map = {};
+  const ext = path.extname(filePath).toLowerCase();
+
+  if (TS_EXTENSIONS.includes(ext)) {
+    const sourceFile = ts.createSourceFile(filePath, code, ts.ScriptTarget.Latest, true);
+    for (const stmt of sourceFile.statements) {
+      if (ts.isVariableStatement(stmt) && stmt.modifiers && stmt.modifiers.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) {
+        for (const decl of stmt.declarationList.declarations) {
+          if (ts.isIdentifier(decl.name) && decl.initializer) {
+            const exportName = decl.name.escapedText;
+            const obj = unwrapFreezeToObjectLiteral(decl.initializer);
+            if (obj) {
+              const entries = objectLiteralToStringMapTS(obj);
+              if (Object.keys(entries).length > 0) {
+                map[exportName] = entries;
+              }
+            }
+          }
+        }
+      }
+    }
+    return map;
+  }
+
+  // JS/JSX – parse with acorn + JSX
+  const parser = acorn.Parser.extend(jsx());
+  let ast;
+  try {
+    ast = parser.parse(code, { ...PARSER_OPTIONS, sourceType: 'module' });
+  } catch (_) {
+    return map;
+  }
+  // Look for export named declarations with const object or Object.freeze
+  ast.body.forEach(node => {
+    if (node.type === 'ExportNamedDeclaration' && node.declaration && node.declaration.type === 'VariableDeclaration') {
+      node.declaration.declarations.forEach(decl => {
+        if (decl.id && decl.id.type === NODE_TYPES.IDENTIFIER && decl.init) {
+          const exportName = decl.id.name;
+          const obj = unwrapFreezeToObjectLiteralJS(decl.init);
+          if (obj && obj.type === NODE_TYPES.OBJECT_EXPRESSION) {
+            const entries = objectExpressionToStringMapJS(obj);
+            if (Object.keys(entries).length > 0) {
+              map[exportName] = entries;
+            }
+          }
+        }
+      });
+    }
+  });
+
+  return map;
+}
+
+function unwrapFreezeToObjectLiteral(initializer) {
+  if (ts.isObjectLiteralExpression(initializer)) return initializer;
+  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])
+    ) {
+      return initializer.arguments[0];
+    }
+  }
+  return null;
+}
+
+function objectLiteralToStringMapTS(obj) {
+  const out = {};
+  for (const prop of obj.properties) {
+    if (!ts.isPropertyAssignment(prop)) continue;
+    const key = ts.isIdentifier(prop.name) ? prop.name.escapedText : ts.isStringLiteral(prop.name) ? prop.name.text : null;
+    if (!key) continue;
+    if (prop.initializer && ts.isStringLiteral(prop.initializer)) {
+      out[key] = prop.initializer.text;
+    }
+  }
+  return out;
+}
+
+function unwrapFreezeToObjectLiteralJS(init) {
+  if (init.type === NODE_TYPES.OBJECT_EXPRESSION) return init;
+  if (init.type === 'CallExpression') {
+    const callee = init.callee;
+    if (
+      callee && callee.type === NODE_TYPES.MEMBER_EXPRESSION &&
+      callee.object && callee.object.type === NODE_TYPES.IDENTIFIER && callee.object.name === 'Object' &&
+      callee.property && callee.property.type === NODE_TYPES.IDENTIFIER && callee.property.name === 'freeze' &&
+      init.arguments && init.arguments.length > 0 && init.arguments[0].type === NODE_TYPES.OBJECT_EXPRESSION
+    ) {
+      return init.arguments[0];
+    }
+  }
+  return null;
+}
+
+function objectExpressionToStringMapJS(obj) {
+  const out = {};
+  obj.properties.forEach(prop => {
+    if (!prop.key || !prop.value) return;
+    const key = prop.key.name || prop.key.value;
+    if (prop.value.type === NODE_TYPES.LITERAL && typeof prop.value.value === 'string') {
+      out[key] = prop.value.value;
+    }
+  });
+  return out;
+}
+
+// Collect imported constant string maps used by this file
+function collectImportedConstantStringMap(filePath, ast) {
+  const fromDir = path.dirname(filePath);
+  const imports = [];
+
+  // ES imports
+  ast.body.forEach(node => {
+    if (node.type === 'ImportDeclaration' && node.source && typeof node.source.value === 'string') {
+      const spec = node.source.value;
+      node.specifiers.forEach(s => {
+        if (s.type === 'ImportSpecifier' && s.imported && s.local) {
+          imports.push({ local: s.local.name, exported: s.imported.name, spec });
+        }
+      });
+    }
+  });
+
+  // CommonJS requires: const { X } = require('mod')
+  ast.body.forEach(node => {
+    if (node.type === 'VariableDeclaration') {
+      node.declarations.forEach(decl => {
+        if (
+          decl.init && decl.init.type === 'CallExpression' &&
+          decl.init.callee && decl.init.callee.type === NODE_TYPES.IDENTIFIER && decl.init.callee.name === 'require' &&
+          decl.init.arguments && decl.init.arguments[0] && decl.init.arguments[0].type === NODE_TYPES.LITERAL
+        ) {
+          const spec = String(decl.init.arguments[0].value);
+          if (decl.id && decl.id.type === 'ObjectPattern') {
+            decl.id.properties.forEach(p => {
+              if (p.key && p.value && p.key.type === NODE_TYPES.IDENTIFIER && p.value.type === NODE_TYPES.IDENTIFIER) {
+                imports.push({ local: p.value.name, exported: p.key.name, spec });
+              }
+            });
+          }
+        }
+      });
+    }
+  });
+
+  const constantMap = {};
+  const bySpec = new Map();
+  for (const imp of imports) {
+    let resolved = bySpec.get(imp.spec);
+    if (!resolved) {
+      const file = resolveModulePath(imp.spec, fromDir);
+      bySpec.set(imp.spec, file || null);
+      resolved = file || null;
+    }
+    if (!resolved) continue;
+    try {
+      const exported = extractExportedConstStringMap(resolved);
+      const entries = exported[imp.exported];
+      if (entries && typeof entries === 'object') {
+        constantMap[imp.local] = entries;
+      }
+    } catch (_) { /* ignore resolution errors */ }
+  }
+
+  return constantMap;
+}
+
+module.exports = {
+  resolveModulePath,
+  extractExportedConstStringMap,
+  collectImportedConstantStringMap
+};
+
+

package/src/analyze/typescript/constants.js

@@ -81,6 +81,12 @@ const ANALYTICS_PROVIDERS = {
     objectNames: ['datadogRum', 'DD_RUM'],
     methodName: 'addAction',
     type: 'member'
+  },
+  GOOGLE_TAG_MANAGER: {
+    name: 'gtm',
+    objectNames: ['dataLayer'],
+    methodName: 'push',
+    type: 'member'
   }
 };
 

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

@@ -44,16 +44,53 @@ function detectAnalyticsSource(node, customFunction) {
  * @returns {boolean}
  */
 function isCustomFunction(node, customFunction) {
-  const canBeCustomFunction = ts.isIdentifier(node.expression) ||
-    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()
-    (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;
+  if (!customFunction || !node || !node.expression) return false;
+
+  // Normalize signature parts by stripping trailing parentheses from each part
+  const parts = customFunction.split('.').map(p => p.replace(/\(\s*\)$/, ''));
+
+  return matchesExpressionChain(node.expression, parts);
+}
+
+/**
+ * Recursively verify that a CallExpression/PropertyAccessExpression chain matches the expected parts.
+ * Supports patterns like getTracker().track, this.props.customTrackFunction6, tracker.track
+ */
+function matchesExpressionChain(expr, parts) {
+  let current = expr;
+  let idx = parts.length - 1;
+
+  while (current && idx >= 0) {
+    const expected = parts[idx];
+
+    if (ts.isPropertyAccessExpression(current)) {
+      const name = current.name?.escapedText;
+      if (name !== expected) return false;
+      current = current.expression;
+      idx -= 1;
+      continue;
+    }
+
+    if (ts.isCallExpression(current)) {
+      // Step into the callee (e.g., getTracker() -> getTracker)
+      current = current.expression;
+      continue;
+    }
+
+    if (ts.isIdentifier(current)) {
+      return idx === 0 && current.escapedText === expected;
+    }
+
+    // Handle `this` without relying on ts.isThisExpression for compatibility across TS versions
+    if (current.kind === ts.SyntaxKind.ThisKeyword || current.kind === ts.SyntaxKind.ThisExpression) {
+      return idx === 0 && expected === 'this';
+    }
+
+    // Unsupported expression kind for our matcher
+    return false;
+  }
+
+  return false;
 }
 
 /**

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

@@ -21,6 +21,7 @@ const EXTRACTION_STRATEGIES = {
   googleanalytics: extractGoogleAnalyticsEvent,
   snowplow: extractSnowplowEvent,
   mparticle: extractMparticleEvent,
+  gtm: extractGTMEvent,
   custom: extractCustomEvent,
   default: extractDefaultEvent
 };
@@ -126,6 +127,60 @@ function extractMparticleEvent(node, checker, sourceFile) {
   return { eventName, propertiesNode };
 }
 
+/**
+ * Extracts Google Tag Manager event data
+ * @param {Object} node - CallExpression node
+ * @param {Object} checker - TypeScript type checker
+ * @param {Object} sourceFile - TypeScript source file
+ * @returns {EventData}
+ */
+function extractGTMEvent(node, checker, sourceFile) {
+  if (!node.arguments || node.arguments.length === 0) {
+    return { eventName: null, propertiesNode: null };
+  }
+
+  // dataLayer.push({ event: 'event_name', property1: 'value1', property2: 'value2' })
+  const firstArg = node.arguments[0];
+  
+  if (!ts.isObjectLiteralExpression(firstArg)) {
+    return { eventName: null, propertiesNode: null };
+  }
+
+  // Find the 'event' property
+  const eventProperty = findPropertyByKey(firstArg, 'event');
+  if (!eventProperty) {
+    return { eventName: null, propertiesNode: null };
+  }
+
+  const eventName = getStringValue(eventProperty.initializer, checker, sourceFile);
+  
+  // Create a modified properties node without the 'event' property
+  const modifiedProperties = firstArg.properties.filter(prop => {
+    if (ts.isPropertyAssignment(prop) && prop.name) {
+      if (ts.isIdentifier(prop.name)) {
+        return prop.name.escapedText !== 'event';
+      }
+      if (ts.isStringLiteral(prop.name)) {
+        return prop.name.text !== 'event';
+      }
+    }
+    return true;
+  });
+
+  // Create a synthetic object literal with the filtered properties
+  const modifiedPropertiesNode = ts.factory.createObjectLiteralExpression(modifiedProperties);
+  
+  // Copy source positions for proper analysis
+  if (firstArg.pos !== undefined) {
+    modifiedPropertiesNode.pos = firstArg.pos;
+  }
+  if (firstArg.end !== undefined) {
+    modifiedPropertiesNode.end = firstArg.end;
+  }
+
+  return { eventName, propertiesNode: modifiedPropertiesNode };
+}
+
 /**
  * Custom extraction
  * @param {Object} node - CallExpression node

package/src/analyze/utils/customFunctionParser.js

@@ -4,15 +4,27 @@ function parseCustomFunctionSignature(signature) {
     return null;
   }
 
-  // Match function name and optional parameter list
-  // Supports names with module prefix like Module.func
-  const match = signature.match(/^\s*([A-Za-z0-9_.]+)\s*(?:\(([^)]*)\))?\s*$/);
-  if (!match) {
-    return null;
-  }
+  const trimmed = signature.trim();
 
-  const functionName = match[1].trim();
-  const paramsPart = match[2];
+  // Two cases:
+  // 1) Full signature with params at the end (e.g., Module.track(EVENT_NAME, PROPERTIES)) → parse params
+  // 2) Name-only (including chains with internal calls, e.g., getService().track) → no params
+  let functionName;
+  let paramsPart = null;
+
+  if (/\)\s*$/.test(trimmed)) {
+    // Looks like it ends with a parameter list – extract the final (...) only
+    const lastOpenIdx = trimmed.lastIndexOf('(');
+    const lastCloseIdx = trimmed.lastIndexOf(')');
+    if (lastOpenIdx === -1 || lastCloseIdx < lastOpenIdx) {
+      return null;
+    }
+    functionName = trimmed.slice(0, lastOpenIdx).trim();
+    paramsPart = trimmed.slice(lastOpenIdx + 1, lastCloseIdx);
+  } else {
+    // No trailing params – treat the whole string as the function name
+    functionName = trimmed;
+  }
 
   // Default legacy behaviour: EVENT_NAME, PROPERTIES
   if (!paramsPart) {