resolve ts imports

Author: skarim

src/analyze/index.js

@@ -44,13 +44,13 @@ function addEventToCollection(allEvents, event, baseDir) {
 }
 
 /**
- * Processes non-TypeScript files
+ * Processes all files that are not TypeScript files
  * @param {Array<string>} files - Array of file paths
  * @param {Object} allEvents - Collection to add events to
  * @param {string} baseDir - Base directory for relative paths
  * @param {Array} customFunctionSignatures - Custom function signatures to detect
  */
-async function processOtherFiles(files, allEvents, baseDir, customFunctionSignatures) {
+async function processFiles(files, allEvents, baseDir, customFunctionSignatures) {
   for (const file of files) {
     let events = [];
 
@@ -97,15 +97,15 @@ async function analyzeDirectory(dirPath, customFunctions) {
     }
   }
 
+  // First process non-TypeScript files
+  await processFiles(otherFiles, allEvents, dirPath, customFunctionSignatures);
+
   // Process TypeScript files with optimized batch processing
   if (tsFiles.length > 0) {
     const tsEvents = analyzeTsFiles(tsFiles, customFunctionSignatures);
     tsEvents.forEach(event => addEventToCollection(allEvents, event, dirPath));
   }
 
-  // Process remaining file types
-  await processOtherFiles(otherFiles, allEvents, dirPath, customFunctionSignatures);
-
   return allEvents;
 }
 

src/analyze/typescript/index.js

@@ -16,7 +16,9 @@ const path = require('path');
 function createStandaloneProgram(filePath) {
   const compilerOptions = {
     ...DEFAULT_COMPILER_OPTIONS,
-    noResolve: true, // Don't try to resolve imports - just analyze the file content
+    // We intentionally allow module resolution here so that imported constants
+    // (e.g. event name strings defined in a sibling file) can be followed by the
+    // TypeScript compiler.
     isolatedModules: true
   };
 
@@ -76,22 +78,28 @@ function tryStandaloneAnalysis(filePath, customFunctionSignatures) {
  * @returns {Object} TypeScript program
  */
 function getCachedTsProgram(filePath, programCache) {
-  // Find the nearest tsconfig.json
+  // Locate nearest tsconfig.json (may be undefined)
   const searchPath = path.dirname(filePath);
   const configPath = ts.findConfigFile(searchPath, ts.sys.fileExists, 'tsconfig.json');
-  
-  // Use config path as cache key, or 'standalone' if no config found
-  const cacheKey = configPath || 'standalone';
-  
-  // Return cached program if available
-  if (programCache.has(cacheKey)) {
+
+  // We only cache when a tsconfig.json exists because the resulting program
+  // represents an entire project.  If no config is present we build a
+  // stand-alone program that should not be reused for other files – otherwise
+  // later files would be missing from the program (which is precisely what
+  // caused the regression we are fixing).
+  const shouldCache = Boolean(configPath);
+  const cacheKey = configPath; // undefined when shouldCache is false
+
+  if (shouldCache && programCache.has(cacheKey)) {
     return programCache.get(cacheKey);
   }
-  
-  // Create new program and cache it
+
   const program = getProgram(filePath, null);
-  programCache.set(cacheKey, program);
-  
+
+  if (shouldCache) {
+    programCache.set(cacheKey, program);
+  }
+
   return program;
 }
 

tests/cli.test.js

@@ -56,6 +56,24 @@ function compareYAMLFiles(actualPath, expectedPath) {
   assert.ok(actual.source);
   assert.ok(actual.source.repository);
 
+  // Helper to sort implementations deterministically
+  const sortImpls = (impls = []) =>
+    impls.slice().sort((a, b) => {
+      if (a.path !== b.path) return a.path.localeCompare(b.path);
+      if (a.line !== b.line) return a.line - b.line;
+      if ((a.destination || '') !== (b.destination || '')) return (a.destination || '').localeCompare(b.destination || '');
+      return (a.function || '').localeCompare(b.function || '');
+    });
+
+  // Normalise events so that order of implementations does not matter
+  const normaliseEvent = (evt) => {
+    if (!evt) return evt;
+    return {
+      ...evt,
+      implementations: sortImpls(evt.implementations)
+    };
+  };
+
   // Compare events using deep equality (order-insensitive)
   const diff = {};
   for (const eventName in expected.events) {
@@ -64,14 +82,17 @@ function compareYAMLFiles(actualPath, expectedPath) {
       continue;
     }
 
-    const actualEvent = actual.events[eventName];
-    const expectedEvent = expected.events[eventName];
+    const actualEvent = normaliseEvent(actual.events[eventName]);
+    const expectedEvent = normaliseEvent(expected.events[eventName]);
 
     if (!_.isEqual(actualEvent, expectedEvent)) {
       diff[eventName] = {
         properties: {
           missing: Object.keys(expectedEvent.properties || {}).filter(p => !actualEvent.properties?.[p]),
-          unexpected: Object.keys(actualEvent.properties || {}).filter(p => !expectedEvent.properties?.[p])
+          unexpected: Object.keys(actualEvent.properties || {}).filter(p => !expectedEvent.properties?.[p]),
+          changed: Object.keys(expectedEvent.properties || {}).filter(p =>
+            actualEvent.properties?.[p] && !_.isEqual(actualEvent.properties[p], expectedEvent.properties[p])
+          )
         },
         implementations: {
           missing: (expectedEvent.implementations || []).filter(impl => 

tests/fixtures/tracking-schema-all.yaml

@@ -989,7 +989,7 @@ events:
         destination: segment
     properties:
       documentId:
-        type: any
+        type: number
       documentType:
         type: string
   cart_viewed: