@flisk/analyze-tracking 0.1.3 → 0.2.0

package/README.md

@@ -11,7 +11,6 @@ npx @flisk/analyze-tracking /path/to/project [options]
 ```
 
 Optional arguments:
-- `--repository <repository_url>`: URL of the repository where the code is hosted (defaults to git remote origin in project directory)
 - `--output <output_file>`: Name of the output file (default: `tracking-schema.yaml`)
 
 
@@ -19,16 +18,18 @@ Optional arguments:
 A YAML file with the following structure is generated:
 
 ```yaml
-version: 1.0
+version: 1
+source:
+  repository: <repository_url>
+  commit: <commit_sha>
+  timestamp: <commit_timestamp>
 events:
   <event_name>:
-    sources:
-      - repository: <repository_name>
-        path: <path_to_file>
+    implementations:
+      - path: <path_to_file>
         line: <line_number>
         function: <function_name>
-    destinations:
-      - <destination_name>
+        destination: <platform_name>
     properties:
       <property_name>:
         type: <property_type>

package/bin/cli.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
 const path = require('path');
-const { execSync } = require('child_process');
 const commandLineArgs = require('command-line-args')
 const { run } = require('../src/index');
 
@@ -12,11 +11,6 @@ const optionDefinitions = [
     type: String,
     defaultOption: true,
   },
-  {
-    name: 'repository',
-    alias: 'r',
-    type: String,
-  },
   {
     name: 'output',
     alias: 'o',
@@ -25,24 +19,11 @@ const optionDefinitions = [
   },
 ]
 const options = commandLineArgs(optionDefinitions);
-const { targetDir, output, repository } = options;
+const { targetDir, output } = options;
 
 if (!targetDir) {
   console.error('Please provide the path to the repository.');
   process.exit(1);
 }
 
-// Get the repository URL using Git
-function getRepositoryUrl() {
-  try {
-    const repoUrl = execSync('git config --get remote.origin.url', { cwd: targetDir, encoding: 'utf8' });
-    return repoUrl.trim();
-  } catch (error) {
-    console.warn('Could not retrieve repository URL. Using default value "unknown".');
-    return 'unknown';
-  }
-}
-
-const repositoryUrl = repository || getRepositoryUrl();
-
-run(path.resolve(targetDir), repositoryUrl, output);
+run(path.resolve(targetDir), output);

package/package.json

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

package/schema.json

@@ -1,30 +1,47 @@
 {
-  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$schema": "http://json-schema.org/draft-07/schema",
   "title": "@flisk/analyze-tracking output schema",
   "type": "object",
   "properties": {
     "version": {
       "type": "number",
       "enum": [
-        1.0
+        1
       ],
       "description": "Version of the schema"
     },
+    "source": {
+      "type": "object",
+      "properties": {
+        "repository": {
+          "type": "string",
+          "description": "URL of git repository that was used to generate the schema"
+        },
+        "commit": {
+          "type": "string",
+          "description": "Git commit hash when this schema was generated"
+        },
+        "timestamp": {
+          "type": "string",
+          "description": "Git commit timestamp when this schema was generated"
+        }
+      },
+      "required": [
+        "timestamp"
+      ],
+      "additionalProperties": false
+    },
     "events": {
       "type": "object",
       "patternProperties": {
         "^[a-zA-Z0-9_-]+$": {
           "type": "object",
           "properties": {
-            "sources": {
+            "implementations": {
               "type": "array",
               "items": {
                 "type": "object",
                 "properties": {
-                  "repository": {
-                    "type": "string",
-                    "description": "Repository URL or name"
-                  },
                   "path": {
                     "type": "string",
                     "description": "Relative path to the file where the event is tracked"
@@ -36,71 +53,84 @@
                   "function": {
                     "type": "string",
                     "description": "Name of the function where the event is tracked"
+                  },
+                  "destination": {
+                    "type": "string",
+                    "enum": [
+                      "googleanalytics",
+                      "segment",
+                      "mixpanel",
+                      "amplitude",
+                      "rudderstack",
+                      "mparticle",
+                      "posthog",
+                      "snowplow",
+                      "unknown"
+                    ],
+                    "description": "Name of the platform where the event is sent"
                   }
                 },
                 "required": [
-                  "repository",
                   "path",
                   "line",
-                  "function"
-                ]
-              }
-            },
-            "destinations": {
-              "type": "array",
-              "items": {
-                "type": "string",
-                "enum": [
-                  "googleanalytics",
-                  "segment",
-                  "mixpanel",
-                  "amplitude",
-                  "rudderstack",
-                  "mparticle",
-                  "snowplow",
-                  "unknown"
+                  "function",
+                  "destination"
                 ],
-                "description": "Destination analytics platform"
+                "additionalProperties": false
               }
             },
             "properties": {
               "type": "object",
               "patternProperties": {
                 "^[a-zA-Z0-9_-]+$": {
-                  "type": "object",
-                  "properties": {
-                    "type": {
-                      "type": "string",
-                      "description": "Data type of the property (e.g., string, number)"
-                    },
-                    "required": {
-                      "type": "boolean",
-                      "description": "Whether this property is required"
-                    },
-                    "description": {
-                      "type": "string",
-                      "description": "Description of the property"
-                    }
-                  },
-                  "required": [
-                    "type"
-                  ]
+                  "$ref": "#/definitions/property"
                 }
               }
             }
           },
           "required": [
-            "sources",
-            "destinations",
+            "implementations",
             "properties"
-          ]
+          ],
+          "additionalProperties": false
         }
-      },
-      "additionalProperties": false
+      }
     }
   },
   "required": [
     "version",
+    "source",
     "events"
-  ]
+  ],
+  "definitions": {
+    "property": {
+      "type": "object",
+      "properties": {
+        "type": {
+          "type": "string",
+          "description": "Data type of the property (e.g., string, number, any)"
+        },
+        "required": {
+          "type": "boolean",
+          "description": "Whether this property is required"
+        },
+        "description": {
+          "type": "string",
+          "description": "Description of the property"
+        },
+        "properties": {
+          "type": "object",
+          "patternProperties": {
+            "^[a-zA-Z0-9_-]+$": {
+              "$ref": "#/definitions/property"
+            }
+          }
+        }
+      },
+      "required": [
+        "type"
+      ],
+      "additionalProperties": false
+    }
+  }
 }

package/src/analyze/index.js

@@ -4,7 +4,7 @@ const { getAllFiles } = require('../fileProcessor');
 const ts = require('typescript');
 const path = require('path');
 
-function analyzeDirectory(dirPath, repository) {
+function analyzeDirectory(dirPath) {
   const files = getAllFiles(dirPath);
   const allEvents = {};
 
@@ -23,27 +23,22 @@ function analyzeDirectory(dirPath, repository) {
 
       if (!allEvents[event.eventName]) {
         allEvents[event.eventName] = {
-          sources: [{
-            repository: repository,
+          implementations: [{
             path: relativeFilePath,
             line: event.line,
-            function: event.functionName
+            function: event.functionName,
+            destination: event.source
           }],
-          destinations: [event.source],
           properties: event.properties,
         };
       } else {
-        allEvents[event.eventName].sources.push({
-          repository: repository,
+        allEvents[event.eventName].implementations.push({
           path: relativeFilePath,
           line: event.line,
-          function: event.functionName
+          function: event.functionName,
+          destination: event.source
         });
 
-        if (!allEvents[event.eventName].destinations.includes(event.source)) {
-          allEvents[event.eventName].destinations.push(event.source);
-        }
-
         allEvents[event.eventName].properties = {
           ...allEvents[event.eventName].properties,
           ...event.properties,

package/src/index.js

@@ -1,9 +1,11 @@
 const { analyzeDirectory } = require('./analyze');
+const { getRepoDetails } = require('./repoDetails');
 const { generateYamlSchema } = require('./yamlGenerator');
 
-function run(targetDir, repository, outputPath) {
-  const events = analyzeDirectory(targetDir, repository);
-  generateYamlSchema(events, outputPath);
+function run(targetDir, outputPath) {
+  const events = analyzeDirectory(targetDir);
+  const repoDetails = getRepoDetails(targetDir);
+  generateYamlSchema(events, repoDetails, outputPath);
 }
 
 module.exports = { run };

package/src/repoDetails.js

@@ -0,0 +1,61 @@
+const { execSync } = require('child_process');
+
+function getRepositoryUrl(targetDir) {
+  try {
+    const repoUrl = execSync('git config --get remote.origin.url', { cwd: targetDir, encoding: 'utf8' });
+    return repoUrl.trim();
+  } catch (error) {
+    console.warn('Could not determine repository URL. Will exclude.');
+    return null;
+  }
+}
+
+function getCommitHash(targetDir) {
+  try {
+    const commitHash = execSync('git rev-parse HEAD', { cwd: targetDir, encoding: 'utf8' });
+    return commitHash.trim();
+  } catch (error) {
+    console.warn('Could not determine latest commit hash. Will exclude.');
+    return null;
+  }
+}
+
+function getCommitTimestamp(targetDir, commitHash) {
+  try {
+    const commitTimestamp = execSync(`git --no-pager show -s --format=%ct ${commitHash}`, { cwd: targetDir, encoding: 'utf8' });
+    const unixTimeSeconds = commitTimestamp.trim();
+    return new Date(unixTimeSeconds * 1000);
+  } catch (error) {
+    console.warn('Could not retrieve commit timestamp. Using current timestamp as default.')
+    return new Date();
+  }
+}
+
+function pad(n) {
+  return n<10 ? '0'+n : n
+}
+
+function toISODateString(date) {  
+  return date.getUTCFullYear()+'-'
+    + pad(date.getUTCMonth()+1)+'-'
+    + pad(date.getUTCDate())+'T'
+    + pad(date.getUTCHours())+':'
+    + pad(date.getUTCMinutes())+':'
+    + pad(date.getUTCSeconds())+'Z'
+}
+
+function getRepoDetails(targetDir) {
+  const repoUrl = getRepositoryUrl(targetDir);
+  const commitHash = getCommitHash(targetDir);
+  const commitEpochTime = getCommitTimestamp(targetDir, commitHash);
+  const commitTimestamp = toISODateString(commitEpochTime);
+
+  const repoDetails = {};
+  if (!!repoUrl) repoDetails.repository = repoUrl;
+  if (!!commitHash) repoDetails.commit = commitHash;
+  repoDetails.timestamp = commitTimestamp
+
+  return repoDetails;
+}
+
+module.exports = { getRepoDetails };

package/src/yamlGenerator.js

@@ -1,14 +1,21 @@
 const fs = require('fs');
 const yaml = require('js-yaml');
 
-function generateYamlSchema(events, outputPath) {
+const VERSION = 1
+const SCHEMA_URL = "https://raw.githubusercontent.com/fliskdata/analyze-tracking/main/schema.json";
+
+function generateYamlSchema(events, repository, outputPath) {
   const schema = {
-    version: 1.0,
+    version: VERSION,
+    source: repository,
     events,
   };
-
-  const yamlOutput = yaml.dump(schema, { noRefs: true });
-  fs.writeFileSync(outputPath, yamlOutput, 'utf8');
+  const options = {
+    noRefs: true,
+  };
+  const yamlOutput = yaml.dump(schema, options);
+  const yamlFile = `# yaml-language-server: $schema=${SCHEMA_URL}\n${yamlOutput}`;
+  fs.writeFileSync(outputPath, yamlFile, 'utf8');
   console.log(`Tracking schema YAML file generated: ${outputPath}`);
 }