@flisk/analyze-tracking 0.7.6 → 0.8.0

package/README.md

@@ -23,38 +23,46 @@ Run without installation! Just use:
 npx @flisk/analyze-tracking /path/to/project [options]
 ```
 
-### Key Options:
+### Key Options
 - `-g, --generateDescription`: Generate descriptions of fields (default: `false`)
 - `-p, --provider <provider>`: Specify a provider (options: `openai`, `gemini`)
 - `-m, --model <model>`: Specify a model (ex: `gpt-4.1-nano`, `gpt-4o-mini`, `gemini-2.0-flash-lite-001`)
 - `-o, --output <output_file>`: Name of the output file (default: `tracking-schema.yaml`)
-- `-c, --customFunction <function_name>`: Specify a custom tracking function
+- `-c, --customFunction <function_signature>`: Specify the signature of your custom tracking function (see [instructions here](#custom-functions))
 - `--format <format>`: Output format, either `yaml` (default) or `json`. If an invalid value is provided, the CLI will exit with an error.
 - `--stdout`: Print the output to the terminal instead of writing to a file (works with both YAML and JSON)
 
 🔑&nbsp; **Important:** If you are using `generateDescription`, you must set the appropriate credentials for the LLM provider you are using as an environment variable. OpenAI uses `OPENAI_API_KEY` and Google Vertex AI uses `GOOGLE_APPLICATION_CREDENTIALS`.
 
-<details>
-  <summary>Note on Custom Functions 💡</summary>
 
-  Use this if you have your own in-house tracker or a wrapper function that calls other tracking libraries.
+### Custom Functions
 
-  We currently only support functions that follow the following format:
-  
-  **JavaScript/TypeScript/Python/Ruby:**
-  ```js
-  yourCustomTrackFunctionName('<event_name>', {
-    <event_parameters>
-  });
-  ```
-  
-  **Go:**
-  ```go
-  yourCustomTrackFunctionName("<event_name>", map[string]any{}{
-    "<property_name>": "<property_value>",
-  })
-  ```
-</details>
+If you have your own in-house tracker or a wrapper function that calls other tracking libraries, you can specify the function signature with the `-c` or `--customFunction` option.
+
+Your function signature should be in the following format:
+```js
+yourCustomTrackFunctionName(EVENT_NAME, PROPERTIES, customFieldOne, customFieldTwo)
+```
+
+- `EVENT_NAME` is the name of the event you are tracking. It should be a string or a pointer to a string. This is required.
+- `PROPERTIES` is an object of properties for that event. It should be an object / dictionary. This is optional.
+- Any additional parameters are other fields you are tracking. They can be of any type. The names you provide for these parameters will be used as the property names in the output.
+
+
+For example, if your function has a userId parameter at the beginning, followed by the event name and properties, you would pass in the following:
+
+```js
+yourCustomTrackFunctionName(userId, EVENT_NAME, PROPERTIES)
+```
+
+If your function follows the standard format `yourCustomTrackFunctionName(EVENT_NAME, PROPERTIES)`, you can simply pass in `yourCustomTrackFunctionName` to `--customFunction` as a shorthand.
+
+You can also pass in multiple custom function signatures by passing in the `--customFunction` option multiple times or by passing in a space-separated list of function signatures.
+
+```sh
+npx @flisk/analyze-tracking /path/to/project --customFunction "yourFunc1" --customFunction "yourFunc2(userId, EVENT_NAME, PROPERTIES)"
+npx @flisk/analyze-tracking /path/to/project -c "yourFunc1" "yourFunc2(userId, EVENT_NAME, PROPERTIES)"
+```
 
 
 ## What's Generated?

package/bin/cli.js

@@ -43,6 +43,7 @@ const optionDefinitions = [
     name: 'customFunction',
     alias: 'c',
     type: String,
+    multiple: true,
   },
   {
     name: 'repositoryUrl',

package/package.json

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

package/src/analyze/go/astTraversal.js

@@ -12,34 +12,34 @@ const { extractTrackingEvent } = require('./trackingExtractor');
  * @param {Array<Object>} events - Array to collect found tracking events (modified in place)
  * @param {string} filePath - Path to the file being analyzed
  * @param {string} functionName - Name of the current function being processed
- * @param {string|null} customFunction - Name of custom tracking function to detect
+ * @param {Object|null} customConfig - Parsed custom function configuration (or null)
  * @param {Object} typeContext - Type information context for variable resolution
  * @param {string} currentFunction - Current function context for type lookups
  */
-function extractEventsFromBody(body, events, filePath, functionName, customFunction, typeContext, currentFunction) {
+function extractEventsFromBody(body, events, filePath, functionName, customConfig, typeContext, currentFunction) {
   for (const stmt of body) {
     if (stmt.tag === 'exec' && stmt.expr) {
-      processExpression(stmt.expr, events, filePath, functionName, customFunction, typeContext, currentFunction);
+      processExpression(stmt.expr, events, filePath, functionName, customConfig, typeContext, currentFunction);
     } else if (stmt.tag === 'declare' && stmt.value) {
       // Handle variable declarations with tracking calls
-      processExpression(stmt.value, events, filePath, functionName, customFunction, typeContext, currentFunction);
+      processExpression(stmt.value, events, filePath, functionName, customConfig, typeContext, currentFunction);
     } else if (stmt.tag === 'assign' && stmt.rhs) {
       // Handle assignments with tracking calls
-      processExpression(stmt.rhs, events, filePath, functionName, customFunction, typeContext, currentFunction);
+      processExpression(stmt.rhs, events, filePath, functionName, customConfig, typeContext, currentFunction);
     } else if (stmt.tag === 'if' && stmt.body) {
-      extractEventsFromBody(stmt.body, events, filePath, functionName, customFunction, typeContext, currentFunction);
+      extractEventsFromBody(stmt.body, events, filePath, functionName, customConfig, typeContext, currentFunction);
     } else if (stmt.tag === 'elseif' && stmt.body) {
-      extractEventsFromBody(stmt.body, events, filePath, functionName, customFunction, typeContext, currentFunction);
+      extractEventsFromBody(stmt.body, events, filePath, functionName, customConfig, typeContext, currentFunction);
     } else if (stmt.tag === 'else' && stmt.body) {
-      extractEventsFromBody(stmt.body, events, filePath, functionName, customFunction, typeContext, currentFunction);
+      extractEventsFromBody(stmt.body, events, filePath, functionName, customConfig, typeContext, currentFunction);
     } else if (stmt.tag === 'for' && stmt.body) {
-      extractEventsFromBody(stmt.body, events, filePath, functionName, customFunction, typeContext, currentFunction);
+      extractEventsFromBody(stmt.body, events, filePath, functionName, customConfig, typeContext, currentFunction);
     } else if (stmt.tag === 'foreach' && stmt.body) {
-      extractEventsFromBody(stmt.body, events, filePath, functionName, customFunction, typeContext, currentFunction);
+      extractEventsFromBody(stmt.body, events, filePath, functionName, customConfig, typeContext, currentFunction);
     } else if (stmt.tag === 'switch' && stmt.cases) {
       for (const caseNode of stmt.cases) {
         if (caseNode.body) {
-          extractEventsFromBody(caseNode.body, events, filePath, functionName, customFunction, typeContext, currentFunction);
+          extractEventsFromBody(caseNode.body, events, filePath, functionName, customConfig, typeContext, currentFunction);
         }
       }
     }
@@ -52,18 +52,18 @@ function extractEventsFromBody(body, events, filePath, functionName, customFunct
  * @param {Array<Object>} events - Array to collect found tracking events (modified in place)
  * @param {string} filePath - Path to the file being analyzed
  * @param {string} functionName - Name of the current function being processed
- * @param {string|null} customFunction - Name of custom tracking function to detect
+ * @param {Object|null} customConfig - Parsed custom function configuration (or null)
  * @param {Object} typeContext - Type information context for variable resolution
  * @param {string} currentFunction - Current function context for type lookups
  * @param {number} [depth=0] - Current recursion depth (used to prevent infinite recursion)
  */
-function processExpression(expr, events, filePath, functionName, customFunction, typeContext, currentFunction, depth = 0) {
+function processExpression(expr, events, filePath, functionName, customConfig, typeContext, currentFunction, depth = 0) {
   if (!expr || depth > MAX_RECURSION_DEPTH) return; // Prevent infinite recursion with depth limit
   
   // Handle array of expressions
   if (Array.isArray(expr)) {
     for (const item of expr) {
-      processExpression(item, events, filePath, functionName, customFunction, typeContext, currentFunction, depth + 1);
+      processExpression(item, events, filePath, functionName, customConfig, typeContext, currentFunction, depth + 1);
     }
     return;
   }
@@ -71,25 +71,25 @@ function processExpression(expr, events, filePath, functionName, customFunction,
   // Handle single expression with body
   if (expr.body) {
     for (const item of expr.body) {
-      processExpression(item, events, filePath, functionName, customFunction, typeContext, currentFunction, depth + 1);
+      processExpression(item, events, filePath, functionName, customConfig, typeContext, currentFunction, depth + 1);
     }
     return;
   }
   
   // Handle specific node types
   if (expr.tag === 'call') {
-    const trackingCall = extractTrackingEvent(expr, filePath, functionName, customFunction, typeContext, currentFunction);
+    const trackingCall = extractTrackingEvent(expr, filePath, functionName, customConfig, typeContext, currentFunction);
     if (trackingCall) {
       events.push(trackingCall);
     }
     
     // Also process call arguments
     if (expr.args) {
-      processExpression(expr.args, events, filePath, functionName, customFunction, typeContext, currentFunction, depth + 1);
+      processExpression(expr.args, events, filePath, functionName, customConfig, typeContext, currentFunction, depth + 1);
     }
   } else if (expr.tag === 'structlit') {
     // Check if this struct literal is a tracking event
-    const trackingCall = extractTrackingEvent(expr, filePath, functionName, customFunction, typeContext, currentFunction);
+    const trackingCall = extractTrackingEvent(expr, filePath, functionName, customConfig, typeContext, currentFunction);
     if (trackingCall) {
       events.push(trackingCall);
     }
@@ -98,7 +98,7 @@ function processExpression(expr, events, filePath, functionName, customFunction,
     if (!trackingCall && expr.fields) {
       for (const field of expr.fields) {
         if (field.value) {
-          processExpression(field.value, events, filePath, functionName, customFunction, typeContext, currentFunction, depth + 1);
+          processExpression(field.value, events, filePath, functionName, customConfig, typeContext, currentFunction, depth + 1);
         }
       }
     }
@@ -106,13 +106,13 @@ function processExpression(expr, events, filePath, functionName, customFunction,
   
   // Process other common properties that might contain expressions
   if (expr.value && expr.tag !== 'structlit') {
-    processExpression(expr.value, events, filePath, functionName, customFunction, typeContext, currentFunction, depth + 1);
+    processExpression(expr.value, events, filePath, functionName, customConfig, typeContext, currentFunction, depth + 1);
   }
   if (expr.lhs) {
-    processExpression(expr.lhs, events, filePath, functionName, customFunction, typeContext, currentFunction, depth + 1);
+    processExpression(expr.lhs, events, filePath, functionName, customConfig, typeContext, currentFunction, depth + 1);
   }
   if (expr.rhs) {
-    processExpression(expr.rhs, events, filePath, functionName, customFunction, typeContext, currentFunction, depth + 1);
+    processExpression(expr.rhs, events, filePath, functionName, customConfig, typeContext, currentFunction, depth + 1);
   }
 }
 

package/src/analyze/go/eventExtractor.js

@@ -10,9 +10,10 @@ const { extractStringValue, findStructLiteral, findStructField, extractSnowplowV
  * Extract event name from a tracking call based on the source
  * @param {Object} callNode - AST node representing a function call or struct literal
  * @param {string} source - Analytics source (e.g., 'segment', 'amplitude')
+ * @param {Object|null} customConfig - Parsed custom function configuration
  * @returns {string|null} Event name or null if not found
  */
-function extractEventName(callNode, source) {
+function extractEventName(callNode, source, customConfig = null) {
   if (!callNode.args || callNode.args.length === 0) {
     // For struct literals, we need to check fields instead of args
     if (!callNode.fields || callNode.fields.length === 0) {
@@ -35,7 +36,7 @@ function extractEventName(callNode, source) {
       return extractSnowplowEventName(callNode);
       
     case ANALYTICS_SOURCES.CUSTOM:
-      return extractCustomEventName(callNode);
+      return extractCustomEventName(callNode, customConfig);
   }
   
   return null;
@@ -142,13 +143,15 @@ function extractSnowplowEventName(callNode) {
  * Extract custom event name
  * Pattern: customFunction("event_name", props)
  * @param {Object} callNode - AST node for custom tracking function call
+ * @param {Object|null} customConfig - Custom configuration object
  * @returns {string|null} Event name or null if not found
  */
-function extractCustomEventName(callNode) {
-  if (callNode.args && callNode.args.length > 0) {
-    return extractStringValue(callNode.args[0]);
-  }
-  return null;
+function extractCustomEventName(callNode, customConfig) {
+  if (!callNode.args || callNode.args.length === 0) return null;
+  const args = callNode.args;
+  const eventIdx = customConfig?.eventIndex ?? 0;
+  const argNode = args[eventIdx];
+  return extractStringValue(argNode);
 }
 
 module.exports = {

package/src/analyze/go/index.js

@@ -12,39 +12,59 @@ const { extractEventsFromBody } = require('./astTraversal');
 /**
  * Analyze a Go file and extract tracking events
  * @param {string} filePath - Path to the Go file to analyze
- * @param {string|null} customFunction - Name of custom tracking function to detect (optional)
+ * @param {string|null} customFunctionSignatures - Signature of custom tracking function to detect (optional)
  * @returns {Promise<Array>} Array of tracking events found in the file
  * @throws {Error} If the file cannot be read or parsed
  */
-async function analyzeGoFile(filePath, customFunction) {
+async function analyzeGoFile(filePath, customFunctionSignatures = null) {
   try {
     // Read the Go file
     const source = fs.readFileSync(filePath, 'utf8');
-    
-    // Parse the Go file using goAstParser
+
+    // Parse the Go file using goAstParser (once)
     const ast = extractGoAST(source);
-    
+
     // First pass: build type information for functions and variables
     const typeContext = buildTypeContext(ast);
-    
-    // Extract tracking events from the AST
-    const events = [];
-    let currentFunction = 'global';
-    
-    // Walk through the AST
-    for (const node of ast) {
-      if (node.tag === 'func') {
-        currentFunction = node.name;
-        // Process the function body
-        if (node.body) {
-          extractEventsFromBody(node.body, events, filePath, currentFunction, customFunction, typeContext, currentFunction);
+
+    const collectEventsForConfig = (customConfig) => {
+      const events = [];
+      let currentFunction = 'global';
+      for (const node of ast) {
+        if (node.tag === 'func') {
+          currentFunction = node.name;
+          if (node.body) {
+            extractEventsFromBody(
+              node.body,
+              events,
+              filePath,
+              currentFunction,
+              customConfig,
+              typeContext,
+              currentFunction
+            );
+          }
         }
       }
+      return events;
+    };
+
+    let events = [];
+
+    // Built-in providers pass (null custom config)
+    events.push(...collectEventsForConfig(null));
+
+    // Custom configs passes
+    if (Array.isArray(customFunctionSignatures) && customFunctionSignatures.length > 0) {
+      for (const customConfig of customFunctionSignatures) {
+        if (!customConfig) continue;
+        events.push(...collectEventsForConfig(customConfig));
+      }
     }
-    
+
     // Deduplicate events based on eventName, source, and function
     const uniqueEvents = deduplicateEvents(events);
-    
+
     return uniqueEvents;
   } catch (error) {
     console.error(`Error analyzing Go file ${filePath}:`, error.message);

package/src/analyze/go/propertyExtractor.js

@@ -12,9 +12,10 @@ const { extractStringValue, findStructLiteral, findStructField, extractFieldName
  * @param {string} source - Analytics source (e.g., 'segment', 'amplitude')
  * @param {Object} typeContext - Type information context for variable resolution
  * @param {string} currentFunction - Current function context for type lookups
+ * @param {Object} customConfig - Custom configuration for property extraction
  * @returns {Object} Object containing extracted properties with their type information
  */
-function extractProperties(callNode, source, typeContext, currentFunction) {
+function extractProperties(callNode, source, typeContext, currentFunction, customConfig) {
   const properties = {};
   
   switch (source) {
@@ -36,7 +37,7 @@ function extractProperties(callNode, source, typeContext, currentFunction) {
       break;
       
     case ANALYTICS_SOURCES.CUSTOM:
-      extractCustomProperties(callNode, properties, typeContext, currentFunction);
+      extractCustomProperties(callNode, properties, typeContext, currentFunction, customConfig);
       break;
   }
   
@@ -270,10 +271,29 @@ function extractSnowplowProperties(callNode, properties, typeContext, currentFun
  * @param {Object} properties - Object to store extracted properties (modified in place)
  * @param {Object} typeContext - Type information context for variable resolution
  * @param {string} currentFunction - Current function context for type lookups
+ * @param {Object} customConfig - Custom configuration for property extraction
  */
-function extractCustomProperties(callNode, properties, typeContext, currentFunction) {
-  if (callNode.args && callNode.args.length > 1) {
-    extractPropertiesFromExpr(callNode.args[1], properties, typeContext, currentFunction);
+function extractCustomProperties(callNode, properties, typeContext, currentFunction, customConfig) {
+  if (!callNode.args || callNode.args.length === 0) return;
+
+  const args = callNode.args;
+
+  const propsIdx = customConfig?.propertiesIndex ?? 1;
+
+  // Extract extra params first (those not event or properties)
+  if (customConfig && Array.isArray(customConfig.extraParams)) {
+    customConfig.extraParams.forEach(param => {
+      const argNode = args[param.idx];
+      if (argNode) {
+        properties[param.name] = getPropertyInfo(argNode, typeContext, currentFunction);
+      }
+    });
+  }
+
+  // Extract properties map/object (if provided)
+  const propsArg = args[propsIdx];
+  if (propsArg) {
+    extractPropertiesFromExpr(propsArg, properties, typeContext, currentFunction);
   }
 }
 

package/src/analyze/go/trackingExtractor.js

@@ -13,19 +13,19 @@ const { extractProperties } = require('./propertyExtractor');
  * @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|null} customConfig - Parsed custom function configuration (or null)
  * @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);
+function extractTrackingEvent(callNode, filePath, functionName, customConfig, typeContext, currentFunction) {
+  const source = detectSource(callNode, customConfig ? customConfig.functionName : null);
   if (!source) return null;
   
-  const eventName = extractEventName(callNode, source);
+  const eventName = extractEventName(callNode, source, customConfig);
   if (!eventName) return null;
   
-  const properties = extractProperties(callNode, source, typeContext, currentFunction);
+  const properties = extractProperties(callNode, source, typeContext, currentFunction, customConfig);
   
   // Get line number based on source type
   let line = 0;

package/src/analyze/index.js

@@ -5,6 +5,7 @@
 
 const path = require('path');
 const ts = require('typescript');
+const { parseCustomFunctionSignature } = require('./utils/customFunctionParser');
 const { getAllFiles } = require('../utils/fileProcessor');
 const { analyzeJsFile } = require('./javascript');
 const { analyzeTsFile } = require('./typescript');
@@ -12,9 +13,11 @@ const { analyzePythonFile } = require('./python');
 const { analyzeRubyFile } = require('./ruby');
 const { analyzeGoFile } = require('./go');
 
-async function analyzeDirectory(dirPath, customFunction) {
+async function analyzeDirectory(dirPath, customFunctions) {
   const allEvents = {};
 
+  const customFunctionSignatures = (customFunctions && customFunctions?.length > 0) ? customFunctions.map(parseCustomFunctionSignature) : null;
+
   const files = getAllFiles(dirPath);
   const tsFiles = files.filter(file => /\.(tsx?)$/.test(file));
   const tsProgram = ts.createProgram(tsFiles, {
@@ -32,15 +35,15 @@ async function analyzeDirectory(dirPath, customFunction) {
     const isGoFile = /\.(go)$/.test(file);
 
     if (isJsFile) {
-      events = analyzeJsFile(file, customFunction);
+      events = analyzeJsFile(file, customFunctionSignatures);
     } else if (isTsFile) {
-      events = analyzeTsFile(file, tsProgram, customFunction);
+      events = analyzeTsFile(file, tsProgram, customFunctionSignatures);
     } else if (isPythonFile) {
-      events = await analyzePythonFile(file, customFunction);
+      events = await analyzePythonFile(file, customFunctionSignatures);
     } else if (isRubyFile) {
-      events = await analyzeRubyFile(file, customFunction);
+      events = await analyzeRubyFile(file, customFunctionSignatures);
     } else if (isGoFile) {
-      events = await analyzeGoFile(file, customFunction);
+      events = await analyzeGoFile(file, customFunctionSignatures);
     } else {
       continue;
     }

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

@@ -43,8 +43,61 @@ function detectAnalyticsSource(node, customFunction) {
  * @returns {boolean}
  */
 function isCustomFunction(node, customFunction) {
-  return node.callee.type === NODE_TYPES.IDENTIFIER && 
-         node.callee.name === customFunction;
+  if (!customFunction) return false;
+
+  // Support dot-separated names like "CustomModule.track"
+  const parts = customFunction.split('.');
+
+  // Simple identifier (no dot)
+  if (parts.length === 1) {
+    return node.callee.type === NODE_TYPES.IDENTIFIER && node.callee.name === customFunction;
+  }
+
+  // For dot-separated names, the callee should be a MemberExpression chain.
+  if (node.callee.type !== NODE_TYPES.MEMBER_EXPRESSION) {
+    return false;
+  }
+
+  return matchesMemberChain(node.callee, parts);
+}
+
+/**
+ * Recursively verifies that a MemberExpression chain matches the expected parts.
+ * Example: parts ["CustomModule", "track"] should match `CustomModule.track()`.
+ * @param {Object} memberExpr - AST MemberExpression node
+ * @param {string[]} parts - Expected name segments (left -> right)
+ * @returns {boolean}
+ */
+function matchesMemberChain(memberExpr, parts) {
+  let currentNode = memberExpr;
+  let idx = parts.length - 1; // start from the rightmost property
+
+  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
+      if (
+        currentNode.property.type !== NODE_TYPES.IDENTIFIER ||
+        currentNode.property.name !== expectedPart
+      ) {
+        return false;
+      }
+
+      // Move to the object of the MemberExpression
+      currentNode = currentNode.object;
+      idx -= 1;
+    } 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 {
+      // Unexpected node type (e.g., ThisExpression, CallExpression, 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,
+  custom: extractCustomEvent,
   default: extractDefaultEvent
 };
 
@@ -27,10 +28,14 @@ const EXTRACTION_STRATEGIES = {
  * Extracts event information from a CallExpression node
  * @param {Object} node - AST CallExpression node
  * @param {string} source - Analytics provider source
+ * @param {Object} customConfig - Parsed custom function configuration
  * @returns {EventData} Extracted event data
  */
-function extractEventData(node, source) {
+function extractEventData(node, source, customConfig) {
   const strategy = EXTRACTION_STRATEGIES[source] || EXTRACTION_STRATEGIES.default;
+  if (source === 'custom') {
+    return strategy(node, customConfig);
+  }
   return strategy(node);
 }
 
@@ -113,6 +118,30 @@ function extractDefaultEvent(node) {
   return { eventName, propertiesNode };
 }
 
+/**
+ * Extracts Custom function event data according to signature
+ * @param {Object} node - CallExpression node
+ * @param {Object} customConfig - Parsed custom function configuration
+ * @returns {EventData & {extraArgs:Object}} event data plus extra args map
+ */
+function extractCustomEvent(node, customConfig) {
+  const args = node.arguments || [];
+
+  const eventArg = args[customConfig?.eventIndex ?? 0];
+  const propertiesArg = args[customConfig?.propertiesIndex ?? 1];
+
+  const eventName = getStringValue(eventArg);
+
+  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 +149,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 +161,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;
@@ -173,6 +221,25 @@ 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';
+  }
+}
+
 module.exports = {
   extractEventData,
   processEventData