Class CachingWorkspace

compiler/companion/src/cache/CachingWorkspace.ts:62–576

const CACHE_TTL_MS = 1000 * 60 * 60 * 24 * 30; // 30 days

export class CachingWorkspace implements IWorkspace {
  get initialized(): boolean {
    return this.workspace.initialized;
  }

  get workspaceRoot(): string {
    return this.workspace.workspaceRoot;
  }

  private fileManager: FileManager;
  private fileInfoCache = new Map<string, CachedFileInfo>();
  private taskQueue = new SerialTaskQueue();

  constructor(
    private readonly workspace: IWorkspace,
    private readonly cache: ICompilationCache,
    private readonly logger: ILogger | undefined,
  ) {
    this.fileManager = new FileManager(workspace.workspaceRoot);
  }

  initialize(): void {
    this.workspace.initialize();
    this.cache.evictEntriesBeforeTime(Date.now() - CACHE_TTL_MS);
  }

  destroy(): void {
    this.workspace.destroy();
    this.cache.close();
  }

  private async measureAndLog<T>(command: string, path: string, work: () => Promise<T>): Promise<T> {
    if (!this.logger) {
      return await work();
    }

    const sw = new Stopwatch();
    this.logger?.debug?.(`Begin ${command} on '${path}'`);
    const result = await work();

    this.logger?.debug?.(`End ${command} on '${path}' in ${sw.elapsedString}`);
    return result;
  }

  private invalidateFileInfo(absolutePath: string): void {
    const fileInfo = this.fileInfoCache.get(absolutePath);
    if (fileInfo) {
      this.fileInfoCache.delete(absolutePath);

      if (fileInfo.dependentFiles) {
        for (const dependentFile of fileInfo.dependentFiles) {
          this.invalidateFileInfo(dependentFile);
        }
      }
    }
  }

  registerInMemoryFile(fileName: string, fileContent: string): void {