@flink-app/flink 0.14.3 → 2.0.0-alpha.100

package/src/DependencyTracker.ts

@@ -0,0 +1,166 @@
+import * as path from 'path';
+import { minimatch } from 'minimatch';
+import { SchemaCache } from './SchemaCache';
+
+export interface CacheTrackingConfig {
+  excludeNodeModules?: boolean;  // Default: true
+  includePatterns?: string[];    // Glob patterns to include despite exclusion
+}
+
+/**
+ * Tracks dependencies and computes content hashes for schema files
+ */
+export class DependencyTracker {
+  private dependencyCache: Map<string, Set<string>> = new Map();
+  private config: CacheTrackingConfig;
+
+  constructor(private projectRoot: string, config?: CacheTrackingConfig) {
+    this.config = {
+      excludeNodeModules: config?.excludeNodeModules ?? true,
+      includePatterns: config?.includePatterns || [],
+    };
+  }
+
+  /**
+   * Check if a file path should be tracked in the cache
+   */
+  private shouldTrackFile(filePath: string): boolean {
+    const isNodeModules = filePath.includes('node_modules');
+
+    // If not in node_modules, always track
+    if (!isNodeModules) {
+      return true;
+    }
+
+    // If excludeNodeModules is false, track all node_modules
+    if (!this.config.excludeNodeModules) {
+      return true;
+    }
+
+    // Check if path matches any include pattern
+    if (this.config.includePatterns && this.config.includePatterns.length > 0) {
+      const relativePath = path.relative(this.projectRoot, filePath);
+      for (const pattern of this.config.includePatterns) {
+        if (minimatch(relativePath, pattern) || minimatch(filePath, pattern)) {
+          return true;
+        }
+      }
+    }
+
+    // Exclude by default
+    return false;
+  }
+
+  /**
+   * Build dependency graph for a schema file
+   * Returns map of absolute file paths to their content hashes
+   */
+  async buildDependencyGraph(
+    schemaFile: string,
+    resolveImports: (filePath: string) => string[]
+  ): Promise<Map<string, string>> {
+    const dependencies = new Map<string, string>();
+    const visited = new Set<string>();
+
+    // Recursively collect all dependencies
+    await this.collectDependencies(schemaFile, resolveImports, visited, dependencies);
+
+    return dependencies;
+  }
+
+  /**
+   * Recursively collect dependencies and compute hashes
+   */
+  private async collectDependencies(
+    filePath: string,
+    resolveImports: (filePath: string) => string[],
+    visited: Set<string>,
+    dependencies: Map<string, string>
+  ): Promise<void> {
+    // Skip if already visited
+    if (visited.has(filePath)) {
+      return;
+    }
+    visited.add(filePath);
+
+    // Check if file should be tracked based on config
+    if (!this.shouldTrackFile(filePath)) {
+      return;
+    }
+
+    // Compute hash for this file
+    const hash = await SchemaCache.hashFile(filePath);
+    if (hash) {
+      dependencies.set(filePath, hash);
+    }
+
+    // Get direct imports
+    const imports = resolveImports(filePath);
+
+    // Recursively process imports
+    await Promise.all(
+      imports.map(importPath =>
+        this.collectDependencies(importPath, resolveImports, visited, dependencies)
+      )
+    );
+  }
+
+  /**
+   * Batch compute hashes for multiple files
+   * Returns map of file paths to hashes
+   */
+  async batchHashFiles(filePaths: string[]): Promise<Map<string, string>> {
+    const hashes = new Map<string, string>();
+
+    // Compute hashes in parallel
+    const results = await Promise.all(
+      filePaths.map(async filePath => ({
+        filePath,
+        hash: await SchemaCache.hashFile(filePath),
+      }))
+    );
+
+    // Build map
+    for (const { filePath, hash } of results) {
+      if (hash) {
+        hashes.set(filePath, hash);
+      }
+    }
+
+    return hashes;
+  }
+
+  /**
+   * Check if any dependencies changed
+   * Returns list of changed file paths
+   */
+  async findChangedDependencies(
+    dependencies: Map<string, string>,
+    cachedHashes: Record<string, string>
+  ): Promise<string[]> {
+    const changed: string[] = [];
+
+    for (const [filePath, currentHash] of Array.from(dependencies.entries())) {
+      const cachedHash = cachedHashes[filePath];
+      if (cachedHash !== currentHash) {
+        changed.push(filePath);
+      }
+    }
+
+    return changed;
+  }
+
+  /**
+   * Get relative path for display purposes
+   */
+  getRelativePath(filePath: string): string {
+    return path.relative(this.projectRoot, filePath);
+  }
+
+  /**
+   * Clear dependency cache
+   */
+  clearCache(): void {
+    this.dependencyCache.clear();
+  }
+}