@flisk/analyze-tracking 0.2.1 → 0.2.3

package/.github/workflows/pr-check.yml

@@ -0,0 +1,17 @@
+name: PR Tests
+
+on:
+  pull_request_target:
+    branches:
+      - main
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm test

package/README.md

@@ -11,7 +11,15 @@ npx @flisk/analyze-tracking /path/to/project [options]
 ```
 
 Optional arguments:
-- `--output <output_file>`: Name of the output file (default: `tracking-schema.yaml`)
+- `-o, --output <output_file>`: Name of the output file (default: `tracking-schema.yaml`)
+- `-c, --customFunction <output_file>`: Name of your custom tracking function
+
+Note: Custom Functions only support the following format:
+```js
+yourCustomTrackFunctionName('<event_name>', {
+  <event_parameters>
+});
+```
 
 
 ## Output Schema
@@ -98,6 +106,22 @@ posthog.capture('<event_name>', {
 ```
 
 
+#### Pendo
+```js
+pendo.track('<event_name>', {
+  <event_parameters>
+});
+```
+
+
+#### Heap
+```js
+heap.track('<event_name>', {
+  <event_parameters>
+});
+```
+
+
 #### Snowplow
 ```js
 snowplow('trackStructEvent', {

package/bin/cli.js

@@ -17,13 +17,18 @@ const optionDefinitions = [
     type: String,
     defaultValue: 'tracking-schema.yaml',
   },
+  {
+    name: 'customFunction',
+    alias: 'c',
+    type: String,
+  },
 ]
 const options = commandLineArgs(optionDefinitions);
-const { targetDir, output } = options;
+const { targetDir, output, customFunction } = options;
 
 if (!targetDir) {
   console.error('Please provide the path to the repository.');
   process.exit(1);
 }
 
-run(path.resolve(targetDir), output);
+run(path.resolve(targetDir), output, customFunction);

package/package.json

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

package/schema.json

@@ -64,7 +64,10 @@
                       "rudderstack",
                       "mparticle",
                       "posthog",
+                      "pendo",
+                      "heap",
                       "snowplow",
+                      "custom",
                       "unknown"
                     ],
                     "description": "Name of the platform where the event is sent"

package/src/analyze/analyzeJsFile.js

@@ -9,14 +9,14 @@ const parser = acorn.Parser.extend(jsx());
 const parserOptions = { ecmaVersion: 'latest', sourceType: 'module', locations: true };
 extend(walk.base);
 
-function analyzeJsFile(filePath) {
+function analyzeJsFile(filePath, customFunction) {
   const code = fs.readFileSync(filePath, 'utf8');
   const ast = parser.parse(code, parserOptions);
   const events = [];
 
   walk.ancestor(ast, {
     CallExpression(node, ancestors) {
-      const source = detectSourceJs(node);
+      const source = detectSourceJs(node, customFunction);
       if (source === 'unknown') return;
 
       let eventName = null;

package/src/analyze/analyzeTsFile.js

@@ -1,14 +1,14 @@
 const ts = require('typescript');
-const { detectSourceTs, findWrappingFunctionTs, extractProperties } = require('./helpers');
+const { detectSourceTs, findWrappingFunctionTs, extractTsProperties } = require('./helpers');
 
-function analyzeTsFile(filePath, program) {
+function analyzeTsFile(filePath, program, customFunction) {
   const sourceFile = program.getSourceFile(filePath);
   const checker = program.getTypeChecker();
   const events = [];
 
   function visit(node) {
     if (ts.isCallExpression(node)) {
-      const source = detectSourceTs(node);
+      const source = detectSourceTs(node, customFunction);
       if (source === 'unknown') return;
 
       let eventName = null;
@@ -30,7 +30,7 @@ function analyzeTsFile(filePath, program) {
       const functionName = findWrappingFunctionTs(node);
 
       if (eventName && propertiesNode && ts.isObjectLiteralExpression(propertiesNode)) {
-        const properties = extractProperties(checker, propertiesNode);
+        const properties = extractTsProperties(checker, propertiesNode);
         events.push({
           eventName,
           source,

package/src/analyze/helpers.js

@@ -1,11 +1,13 @@
 const ts = require('typescript');
 
-function detectSourceJs(node) {
+function detectSourceJs(node, customFunction) {
   if (!node.callee) return 'unknown';
 
   if (node.callee.type === 'Identifier' && node.callee.name === 'gtag') {
     return 'googleanalytics';
-  } else if (node.callee.type === 'MemberExpression') {
+  }
+
+  if (node.callee.type === 'MemberExpression') {
     const objectName = node.callee.object.name;
     const methodName = node.callee.property.name;
 
@@ -15,19 +17,29 @@ function detectSourceJs(node) {
     if (objectName === 'rudderanalytics' && methodName === 'track') return 'rudderstack';
     if (objectName === 'mParticle' && methodName === 'logEvent') return 'mparticle';
     if (objectName === 'posthog' && methodName === 'capture') return 'posthog';
-  } else if (node.callee.type === 'Identifier' && node.callee.name === 'snowplow') {
+    if (objectName === 'pendo' && methodName === 'track') return 'pendo';
+    if (objectName === 'heap' && methodName === 'track') return 'heap';
+  }
+
+  if (node.callee.type === 'Identifier' && node.callee.name === 'snowplow') {
     return 'snowplow';
   }
 
+  if (node.callee.type === 'Identifier' && node.callee.name === customFunction) {
+    return 'custom';
+  }
+
   return 'unknown';
 }
 
-function detectSourceTs(node) {
+function detectSourceTs(node, customFunction) {
   if (!node.expression) return 'unknown';
 
   if (ts.isIdentifier(node.expression) && node.expression.escapedText === 'gtag') {
     return 'googleanalytics';
-  } else if (ts.isPropertyAccessExpression(node.expression)) {
+  }
+  
+  if (ts.isPropertyAccessExpression(node.expression)) {
     const objectName = node.expression.expression.escapedText;
     const methodName = node.expression.name.escapedText;
 
@@ -37,10 +49,18 @@ function detectSourceTs(node) {
     if (objectName === 'rudderanalytics' && methodName === 'track') return 'rudderstack';
     if (objectName === 'mParticle' && methodName === 'logEvent') return 'mparticle';
     if (objectName === 'posthog' && methodName === 'capture') return 'posthog';
-  } else if (ts.isIdentifier(node.expression) && node.expression.escapedText === 'snowplow') {
+    if (objectName === 'pendo' && methodName === 'track') return 'pendo';
+    if (objectName === 'heap' && methodName === 'track') return 'heap';
+  }
+  
+  if (ts.isIdentifier(node.expression) && node.expression.escapedText === 'snowplow') {
     return 'snowplow';
   }
 
+  if (ts.isIdentifier(node.expression) && node.expression.escapedText === customFunction) {
+    return 'custom';
+  }
+
   return 'unknown';
 }
 
@@ -116,18 +136,24 @@ function extractJsProperties(node) {
   return properties;
 }
 
-function extractProperties(checker, node) {
+function extractTsProperties(checker, node) {
   const properties = {};
 
   node.properties.forEach((prop) => {
     const key = prop.name ? prop.name.text : prop.key.text || prop.key.value;
     let valueType = 'any';
 
-    if (prop.initializer) {
+    if (ts.isShorthandPropertyAssignment(prop)) {
+      const symbol = checker.getSymbolAtLocation(prop.name);
+      if (symbol) {
+        valueType = getTypeOfNode(checker, symbol.valueDeclaration);
+        properties[key] = { type: valueType };
+      }
+    } else if (prop.initializer) {
       if (ts.isObjectLiteralExpression(prop.initializer)) {
         properties[key] = {
           type: 'object',
-          properties: extractProperties(checker, prop.initializer),
+          properties: extractTsProperties(checker, prop.initializer),
         };
       } else if (ts.isArrayLiteralExpression(prop.initializer)) {
         properties[key] = {
@@ -137,7 +163,32 @@ function extractProperties(checker, node) {
           },
         };
       } else {
-        valueType = getTypeOfNode(checker, prop.initializer) || 'any';
+        // Handle hard-coded values
+        switch (prop.initializer.kind) {
+          case ts.SyntaxKind.StringLiteral:
+            valueType = 'string';
+            break;
+          case ts.SyntaxKind.NumericLiteral:
+            valueType = 'number';
+            break;
+          case ts.SyntaxKind.TrueKeyword:
+          case ts.SyntaxKind.FalseKeyword:
+            valueType = 'boolean';
+            break;
+          case ts.SyntaxKind.ArrayLiteralExpression:
+            valueType = 'array';
+            break;
+          case ts.SyntaxKind.ObjectLiteralExpression:
+            valueType = 'object';
+            break;
+          default:
+            valueType = 'any';
+        }
+
+        if (valueType === 'any') {
+          valueType = getTypeOfNode(checker, prop.initializer) || 'any';
+        }
+
         properties[key] = { type: valueType };
       }
     } else if (prop.type) {
@@ -160,6 +211,6 @@ module.exports = {
   findWrappingFunctionTs,
   findWrappingFunctionJs,
   extractJsProperties,
-  extractProperties,
+  extractTsProperties,
   getTypeOfNode,
 };

package/src/analyze/index.js

@@ -4,7 +4,7 @@ const { getAllFiles } = require('../fileProcessor');
 const ts = require('typescript');
 const path = require('path');
 
-function analyzeDirectory(dirPath) {
+function analyzeDirectory(dirPath, customFunction) {
   const files = getAllFiles(dirPath);
   const allEvents = {};
 
@@ -16,7 +16,7 @@ function analyzeDirectory(dirPath) {
 
   files.forEach((file) => {
     const isTsFile = /\.(tsx?)$/.test(file);
-    const events = isTsFile ? analyzeTsFile(file, program) : analyzeJsFile(file);
+    const events = isTsFile ? analyzeTsFile(file, program, customFunction) : analyzeJsFile(file, customFunction);
 
     events.forEach((event) => {
       const relativeFilePath = path.relative(dirPath, event.filePath); // Calculate relative path

package/src/index.js

@@ -2,8 +2,8 @@ const { analyzeDirectory } = require('./analyze');
 const { getRepoDetails } = require('./repoDetails');
 const { generateYamlSchema } = require('./yamlGenerator');
 
-function run(targetDir, outputPath) {
-  const events = analyzeDirectory(targetDir);
+function run(targetDir, outputPath, customFunction) {
+  const events = analyzeDirectory(targetDir, customFunction);
   const repoDetails = getRepoDetails(targetDir);
   generateYamlSchema(events, repoDetails, outputPath);
 }

package/tests/extractProperties.test.js

@@ -1,7 +1,7 @@
 const ts = require('typescript');
 const {
   extractJsProperties,
-  extractProperties,
+  extractTsProperties,
 } = require('../src/analyze/helpers');
 
 describe('extractJsProperties', () => {
@@ -69,7 +69,7 @@ describe('extractTsProperties', () => {
       getTypeAtLocation: jest.fn().mockReturnValue({}),
       typeToString: jest.fn().mockReturnValue('string'),
     };
-    const properties = extractProperties(checker, node);
+    const properties = extractTsProperties(checker, node);
     expect(properties).toEqual({
       userId: { type: 'string' },
       plan: { type: 'string' },
@@ -95,7 +95,7 @@ describe('extractTsProperties', () => {
       getTypeAtLocation: jest.fn().mockReturnValue({}),
       typeToString: jest.fn().mockReturnValue('string'),
     };
-    const properties = extractProperties(checker, node);
+    const properties = extractTsProperties(checker, node);
     expect(properties).toEqual({
       address: {
         type: 'object',