@flisk/analyze-tracking 0.1.0 → 0.1.1

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,33 @@
+name: Publish Package to NPM
+
+on:
+  release:
+    types: [published]
+
+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
+
+  publish:
+    needs: test
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm publish --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -1,6 +1,10 @@
 # @flisk/analyze-tracking
+
 Analyzes tracking code in a project and generates data schemas
 
+[![NPM version](https://img.shields.io/npm/v/@flisk/analyze-tracking.svg)](https://www.npmjs.com/package/@flisk/analyze-tracking)
+
+
 ## Usage
 ```sh
 npx @flisk/analyze-tracking /path/to/project

package/jest.config.js

@@ -0,0 +1,7 @@
+module.exports = {
+  testEnvironment: 'node',
+  verbose: true,
+  collectCoverage: true,
+  coverageDirectory: 'coverage',
+  testMatch: ['**/?(*.)+(spec|test).[jt]s?(x)'],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flisk/analyze-tracking",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Analyzes tracking code in a project and generates data schemas",
   "main": "src/index.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/analyze-tracking.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest"
   },
   "repository": {
     "type": "git",
@@ -26,5 +26,8 @@
     "acorn-walk": "^8.3.3",
     "js-yaml": "^4.1.0",
     "typescript": "^5.5.4"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
   }
 }

package/src/analyze/analyzeJsFile.js

@@ -29,7 +29,7 @@ function analyzeJsFile(filePath) {
       }
 
       const line = node.loc.start.line;
-      const functionName = findWrappingFunctionJs(ancestors[ancestors.length - 2]);
+      const functionName = findWrappingFunctionJs(node, ancestors);
 
       if (eventName && propertiesNode && propertiesNode.type === 'ObjectExpression') {
         const properties = extractJsProperties(propertiesNode);

package/src/analyze/helpers.js

@@ -53,13 +53,37 @@ function findWrappingFunctionTs(node) {
   return 'global';
 }
 
-function findWrappingFunctionJs(node) {
-  let current = node;
-  while (current) {
-    if (current.type === 'FunctionDeclaration' || current.type === 'FunctionExpression' || current.type === 'ArrowFunctionExpression') {
+function findWrappingFunctionJs(node, ancestors) {
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    const current = ancestors[i];
+
+    // Handle direct variable assignments (e.g., const myFunc = () => {})
+    if (current.type === 'VariableDeclarator' && current.init === node) {
+      return current.id.name;
+    }
+
+    // Handle arrow functions or function expressions assigned to variables
+    if (current.type === 'VariableDeclarator' && (current.init.type === 'ArrowFunctionExpression' || current.init.type === 'FunctionExpression')) {
+      return current.id.name;
+    }
+
+    // Handle named function declarations
+    if (current.type === 'FunctionDeclaration') {
       return current.id ? current.id.name : 'anonymous';
     }
-    current = current.parent;
+
+    // Handle exported variable/function (e.g., export const myFunc = () => {})
+    if (current.type === 'ExportNamedDeclaration' && current.declaration) {
+      const declaration = current.declaration.declarations ? current.declaration.declarations[0] : null;
+      if (declaration && (declaration.init.type === 'ArrowFunctionExpression' || declaration.init.type === 'FunctionExpression')) {
+        return declaration.id.name;
+      }
+    }
+
+    // Handle methods within object literals
+    if (current.type === 'Property' && current.value === node) {
+      return current.key.name || current.key.value;
+    }
   }
   return 'global';
 }

package/tests/detectSource.test.js

@@ -0,0 +1,20 @@
+const {
+  detectSourceJs,
+} = require('../src/analyze/helpers');
+
+describe('detectSourceJs', () => {
+  it('should detect Google Analytics', () => {
+    const node = { callee: { type: 'Identifier', name: 'gtag' } };
+    expect(detectSourceJs(node)).toBe('googleanalytics');
+  });
+
+  it('should detect Segment', () => {
+    const node = { callee: { type: 'MemberExpression', object: { name: 'analytics' }, property: { name: 'track' } } };
+    expect(detectSourceJs(node)).toBe('segment');
+  });
+
+  it('should return unknown for unrecognized source', () => {
+    const node = { callee: { type: 'Identifier', name: 'unknownLib' } };
+    expect(detectSourceJs(node)).toBe('unknown');
+  });
+});

package/tests/extractProperties.test.js

@@ -0,0 +1,109 @@
+const ts = require('typescript');
+const {
+  extractJsProperties,
+  extractProperties,
+} = require('../src/analyze/helpers');
+
+describe('extractJsProperties', () => {
+  it('should extract simple properties', () => {
+    const node = {
+      properties: [
+        { key: { name: 'userId' }, value: { value: '12345', type: 'Literal' } },
+        { key: { name: 'plan' }, value: { value: 'Free', type: 'Literal' } },
+      ],
+    };
+    const properties = extractJsProperties(node);
+    expect(properties).toEqual({
+      userId: { type: 'string' },
+      plan: { type: 'string' },
+    });
+  });
+
+  it('should handle nested object properties', () => {
+    const node = {
+      properties: [
+        {
+          key: { name: 'address' },
+          value: {
+            type: 'ObjectExpression',
+            properties: [
+              { key: { name: 'city' }, value: { value: 'San Francisco', type: 'Literal' } },
+              { key: { name: 'state' }, value: { value: 'CA', type: 'Literal' } },
+            ],
+          },
+        },
+      ],
+    };
+    const properties = extractJsProperties(node);
+    expect(properties).toEqual({
+      address: {
+        type: 'object',
+        properties: {
+          city: { type: 'string' },
+          state: { type: 'string' },
+        },
+      },
+    });
+  });
+
+  it('should handle properties with undefined type', () => {
+    const node = {
+      properties: [{ key: { name: 'undefinedProp' }, value: { value: undefined, type: 'Literal' } }],
+    };
+    const properties = extractJsProperties(node);
+    expect(properties).toEqual({
+      undefinedProp: { type: 'any' },
+    });
+  });
+});
+
+describe('extractTsProperties', () => {
+  it('should extract properties from TypeScript object', () => {
+    const node = {
+      properties: [
+        { name: { text: 'userId' }, initializer: { text: '12345', type: 'Literal' } },
+        { name: { text: 'plan' }, initializer: { text: 'Free', type: 'Literal' } },
+      ],
+    };
+    const checker = {
+      getTypeAtLocation: jest.fn().mockReturnValue({}),
+      typeToString: jest.fn().mockReturnValue('string'),
+    };
+    const properties = extractProperties(checker, node);
+    expect(properties).toEqual({
+      userId: { type: 'string' },
+      plan: { type: 'string' },
+    });
+  });
+
+  it('should handle nested object properties in TypeScript', () => {
+    const node = {
+      properties: [
+        {
+          name: { text: 'address' },
+          initializer: {
+            kind: ts.SyntaxKind.ObjectLiteralExpression,
+            properties: [
+              { name: { text: 'city' }, initializer: { text: 'San Francisco', type: 'Literal' } },
+              { name: { text: 'state' }, initializer: { text: 'CA', type: 'Literal' } },
+            ],
+          },
+        },
+      ],
+    };
+    const checker = {
+      getTypeAtLocation: jest.fn().mockReturnValue({}),
+      typeToString: jest.fn().mockReturnValue('string'),
+    };
+    const properties = extractProperties(checker, node);
+    expect(properties).toEqual({
+      address: {
+        type: 'object',
+        properties: {
+          city: { type: 'string' },
+          state: { type: 'string' },
+        },
+      },
+    });
+  });
+});

package/tests/findWrappingFunction.test.js

@@ -0,0 +1,30 @@
+const ts = require('typescript');
+const {
+  findWrappingFunctionJs,
+} = require('../src/analyze/helpers');
+
+describe('findWrappingFunctionJs', () => {
+  it('should return function name for arrow function assigned to variable', () => {
+    const node = { type: 'ArrowFunctionExpression' };
+    const ancestors = [
+      { type: 'Program' },
+      { type: 'VariableDeclarator', init: node, id: { name: 'checkout' } },
+    ];
+    expect(findWrappingFunctionJs(node, ancestors)).toBe('checkout');
+  });
+
+  it('should return function name for function expression assigned to variable', () => {
+    const node = { type: 'FunctionExpression' };
+    const ancestors = [
+      { type: 'Program' },
+      { type: 'VariableDeclarator', init: node, id: { name: 'myFunc' } },
+    ];
+    expect(findWrappingFunctionJs(node, ancestors)).toBe('myFunc');
+  });
+
+  it('should return "global" if no wrapping function is found', () => {
+    const node = {};
+    const ancestors = [{ type: 'Program' }];
+    expect(findWrappingFunctionJs(node, ancestors)).toBe('global');
+  });
+});