@atlaspack/core 2.12.1-canary.3430 → 2.12.1-canary.3432

package/lib/Atlaspack.js

@@ -520,6 +520,9 @@ class Atlaspack {
     });
     return this.#farm.takeHeapSnapshot();
   }
+  async unstable_invalidate() {
+    await this._init();
+  }
   async unstable_transform(options) {
     var _options$env;
     if (!this.#initialized) {

package/lib/RequestTracker.js

@@ -465,18 +465,32 @@ class RequestGraph extends _graph().ContentGraph {
       return node;
     });
   }
-  invalidateFileNameNode(node, filePath, matchNodes) {
+  invalidateFileNameNode(node, filePath, matchNodes, invalidateNode) {
     // If there is an edge between this file_name node and one of the original file nodes pointed to
     // by the original file_name node, and the matched node is inside the current directory, invalidate
     // all connected requests pointed to by the file node.
-    let dirname = _path2().default.dirname((0, _projectPath.fromProjectPathRelative)(filePath));
+
     let nodeId = this.getNodeIdByContentKey(node.id);
-    for (let matchNode of matchNodes) {
-      let matchNodeId = this.getNodeIdByContentKey(matchNode.id);
-      if (this.hasEdge(nodeId, matchNodeId, requestGraphEdgeTypes.invalidated_by_create_above) && (0, _utils().isDirectoryInside)((0, _projectPath.fromProjectPathRelative)((0, _projectPath.toProjectPathUnsafe)(matchNode.id)), dirname)) {
-        let connectedNodes = this.getNodeIdsConnectedTo(matchNodeId, requestGraphEdgeTypes.invalidated_by_create);
+    let dirname = _path2().default.dirname((0, _projectPath.fromProjectPathRelative)(filePath));
+    if ((0, _featureFlags().getFeatureFlag)('fixQuadraticCacheInvalidation')) {
+      while (dirname !== '/') {
+        if (!this.hasContentKey(dirname)) break;
+        const matchNodeId = this.getNodeIdByContentKey(dirname);
+        if (!this.hasEdge(nodeId, matchNodeId, requestGraphEdgeTypes.invalidated_by_create_above)) break;
+        const connectedNodes = this.getNodeIdsConnectedTo(matchNodeId, requestGraphEdgeTypes.invalidated_by_create);
         for (let connectedNode of connectedNodes) {
-          this.invalidateNode(connectedNode, _constants.FILE_CREATE);
+          invalidateNode(connectedNode, _constants.FILE_CREATE);
+        }
+        dirname = _path2().default.dirname(dirname);
+      }
+    } else {
+      for (let matchNode of matchNodes) {
+        let matchNodeId = this.getNodeIdByContentKey(matchNode.id);
+        if (this.hasEdge(nodeId, matchNodeId, requestGraphEdgeTypes.invalidated_by_create_above) && (0, _utils().isDirectoryInside)((0, _projectPath.fromProjectPathRelative)((0, _projectPath.toProjectPathUnsafe)(matchNode.id)), dirname)) {
+          let connectedNodes = this.getNodeIdsConnectedTo(matchNodeId, requestGraphEdgeTypes.invalidated_by_create);
+          for (let connectedNode of connectedNodes) {
+            this.invalidateNode(connectedNode, _constants.FILE_CREATE);
+          }
         }
       }
     }
@@ -489,7 +503,7 @@ class RequestGraph extends _graph().ContentGraph {
       if (this.hasEdge(nodeId, this.getNodeIdByContentKey(contentKey), requestGraphEdgeTypes.dirname)) {
         let parent = (0, _nullthrows().default)(this.getNodeByContentKey(contentKey));
         (0, _assert().default)(parent.type === FILE_NAME);
-        this.invalidateFileNameNode(parent, (0, _projectPath.toProjectPathUnsafe)(dirname), matchNodes);
+        this.invalidateFileNameNode(parent, (0, _projectPath.toProjectPathUnsafe)(dirname), matchNodes, invalidateNode);
       }
     }
   }
@@ -498,12 +512,38 @@ class RequestGraph extends _graph().ContentGraph {
     let count = 0;
     let predictedTime = 0;
     let startTime = Date.now();
-    const removeOrphans = !(0, _featureFlags().getFeatureFlag)('fixQuadraticCacheInvalidation');
+    const enableOptimization = (0, _featureFlags().getFeatureFlag)('fixQuadraticCacheInvalidation');
+    const removeOrphans = !enableOptimization;
+    const invalidatedNodes = new Set();
+    const invalidateNode = (nodeId, reason) => {
+      if (enableOptimization && invalidatedNodes.has(nodeId)) {
+        return;
+      }
+      invalidatedNodes.add(nodeId);
+      this.invalidateNode(nodeId, reason);
+    };
+    const aboveCache = new Map();
+    const getAbove = fileNameNodeId => {
+      const cachedResult = aboveCache.get(fileNameNodeId);
+      if (enableOptimization && cachedResult) {
+        return cachedResult;
+      }
+      let above = [];
+      const children = this.getNodeIdsConnectedTo(fileNameNodeId, requestGraphEdgeTypes.invalidated_by_create_above);
+      for (const nodeId of children) {
+        let node = (0, _nullthrows().default)(this.getNode(nodeId));
+        if (node.type === FILE) {
+          above.push(node);
+        }
+      }
+      aboveCache.set(fileNameNodeId, above);
+      return above;
+    };
     for (let {
       path: _path,
       type
     } of events) {
-      if (++count === 256) {
+      if (!enableOptimization && process.env.ATLASPACK_DISABLE_CACHE_TIMEOUT !== 'true' && ++count === 256) {
         let duration = Date.now() - startTime;
         predictedTime = duration * (events.length >> 8);
         if (predictedTime > threshold) {
@@ -550,13 +590,13 @@ class RequestGraph extends _graph().ContentGraph {
         let nodes = this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_update);
         for (let connectedNode of nodes) {
           didInvalidate = true;
-          this.invalidateNode(connectedNode, _constants.FILE_UPDATE);
+          invalidateNode(connectedNode, _constants.FILE_UPDATE);
         }
         if (type === 'create') {
           let nodes = this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_create);
           for (let connectedNode of nodes) {
             didInvalidate = true;
-            this.invalidateNode(connectedNode, _constants.FILE_CREATE);
+            invalidateNode(connectedNode, _constants.FILE_CREATE);
           }
         }
       } else if (type === 'create') {
@@ -566,17 +606,10 @@ class RequestGraph extends _graph().ContentGraph {
           let fileNameNodeId = this.getNodeIdByContentKey('file_name:' + basename);
 
           // Find potential file nodes to be invalidated if this file name pattern matches
-          let above = [];
-          for (const nodeId of this.getNodeIdsConnectedTo(fileNameNodeId, requestGraphEdgeTypes.invalidated_by_create_above)) {
-            let node = (0, _nullthrows().default)(this.getNode(nodeId));
-            // these might also be `glob` nodes which get handled below, we only care about files here.
-            if (node.type === FILE) {
-              above.push(node);
-            }
-          }
+          let above = getAbove(fileNameNodeId);
           if (above.length > 0) {
             didInvalidate = true;
-            this.invalidateFileNameNode(fileNameNode, _filePath, above);
+            this.invalidateFileNameNode(fileNameNode, _filePath, above, invalidateNode);
           }
         }
         for (let globeNodeId of this.globNodeIds) {
@@ -586,7 +619,7 @@ class RequestGraph extends _graph().ContentGraph {
             let connectedNodes = this.getNodeIdsConnectedTo(globeNodeId, requestGraphEdgeTypes.invalidated_by_create);
             for (let connectedNode of connectedNodes) {
               didInvalidate = true;
-              this.invalidateNode(connectedNode, _constants.FILE_CREATE);
+              invalidateNode(connectedNode, _constants.FILE_CREATE);
             }
           }
         }
@@ -594,7 +627,7 @@ class RequestGraph extends _graph().ContentGraph {
         let nodeId = this.getNodeIdByContentKey(filePath);
         for (let connectedNode of this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_delete)) {
           didInvalidate = true;
-          this.invalidateNode(connectedNode, _constants.FILE_DELETE);
+          invalidateNode(connectedNode, _constants.FILE_DELETE);
         }
 
         // Delete the file node since it doesn't exist anymore.
@@ -614,7 +647,7 @@ class RequestGraph extends _graph().ContentGraph {
           }
           if (isInvalid) {
             for (let connectedNode of this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_update)) {
-              this.invalidateNode(connectedNode, type === 'delete' ? _constants.FILE_DELETE : _constants.FILE_UPDATE);
+              invalidateNode(connectedNode, type === 'delete' ? _constants.FILE_DELETE : _constants.FILE_UPDATE);
             }
             didInvalidate = true;
             this.removeNode(nodeId, removeOrphans);
@@ -632,7 +665,9 @@ class RequestGraph extends _graph().ContentGraph {
       meta: {
         trackableEvent: 'fsevent_response_time',
         duration,
-        predictedTime
+        predictedTime,
+        numberOfEvents: events.length,
+        numberOfInvalidatedNodes: invalidatedNodes.size
       }
     });
     return didInvalidate && this.invalidNodeIds.size > 0;
@@ -1035,7 +1070,16 @@ async function loadRequestGraph(options) {
   let cacheKey = getCacheKey(options);
   let requestGraphKey = `requestGraph-${cacheKey}`;
   let timeout;
-  const snapshotPath = _path2().default.join(options.cacheDir, `snapshot-${cacheKey}` + '.txt');
+  const snapshotKey = `snapshot-${cacheKey}`;
+  const snapshotPath = _path2().default.join(options.cacheDir, snapshotKey + '.txt');
+  _logger().default.verbose({
+    origin: '@atlaspack/core',
+    message: 'Loading request graph',
+    meta: {
+      cacheKey,
+      snapshotKey
+    }
+  });
   if (await options.cache.hasLargeBlob(requestGraphKey)) {
     try {
       let {
@@ -1075,6 +1119,14 @@ async function loadRequestGraph(options) {
       return new RequestGraph();
     }
   }
+  _logger().default.verbose({
+    origin: '@atlaspack/core',
+    message: 'Cache entry for request tracker was not found, initializing a clean cache.',
+    meta: {
+      cacheKey,
+      snapshotKey
+    }
+  });
   return new RequestGraph();
 }
 function logErrorOnBailout(options, snapshotPath, e) {
@@ -1101,6 +1153,9 @@ function logErrorOnBailout(options, snapshotPath, e) {
   }
 }
 function cleanUpOrphans(graph) {
+  if (graph.rootNodeId == null) {
+    return [];
+  }
   const reachableNodes = new Set();
   graph.traverse(nodeId => {
     reachableNodes.add(nodeId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-canary.3430+7ad3bbfcb",
+  "version": "2.12.1-canary.3432+415929ab6",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,20 +20,20 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/cache": "2.12.1-canary.3430+7ad3bbfcb",
-    "@atlaspack/diagnostic": "2.12.1-canary.3430+7ad3bbfcb",
-    "@atlaspack/events": "2.12.1-canary.3430+7ad3bbfcb",
-    "@atlaspack/feature-flags": "2.12.1-canary.3430+7ad3bbfcb",
-    "@atlaspack/fs": "2.12.1-canary.3430+7ad3bbfcb",
-    "@atlaspack/graph": "3.2.1-canary.3430+7ad3bbfcb",
-    "@atlaspack/logger": "2.12.1-canary.3430+7ad3bbfcb",
-    "@atlaspack/package-manager": "2.12.1-canary.3430+7ad3bbfcb",
-    "@atlaspack/plugin": "2.12.1-canary.3430+7ad3bbfcb",
-    "@atlaspack/profiler": "2.12.1-canary.3430+7ad3bbfcb",
-    "@atlaspack/rust": "2.12.1-canary.3430+7ad3bbfcb",
-    "@atlaspack/types": "2.12.1-canary.3430+7ad3bbfcb",
-    "@atlaspack/utils": "2.12.1-canary.3430+7ad3bbfcb",
-    "@atlaspack/workers": "2.12.1-canary.3430+7ad3bbfcb",
+    "@atlaspack/cache": "2.12.1-canary.3432+415929ab6",
+    "@atlaspack/diagnostic": "2.12.1-canary.3432+415929ab6",
+    "@atlaspack/events": "2.12.1-canary.3432+415929ab6",
+    "@atlaspack/feature-flags": "2.12.1-canary.3432+415929ab6",
+    "@atlaspack/fs": "2.12.1-canary.3432+415929ab6",
+    "@atlaspack/graph": "3.2.1-canary.3432+415929ab6",
+    "@atlaspack/logger": "2.12.1-canary.3432+415929ab6",
+    "@atlaspack/package-manager": "2.12.1-canary.3432+415929ab6",
+    "@atlaspack/plugin": "2.12.1-canary.3432+415929ab6",
+    "@atlaspack/profiler": "2.12.1-canary.3432+415929ab6",
+    "@atlaspack/rust": "2.12.1-canary.3432+415929ab6",
+    "@atlaspack/types": "2.12.1-canary.3432+415929ab6",
+    "@atlaspack/utils": "2.12.1-canary.3432+415929ab6",
+    "@atlaspack/workers": "2.12.1-canary.3432+415929ab6",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -57,5 +57,5 @@
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "7ad3bbfcbddc6764dfdc9c4660341b003911cc07"
+  "gitHead": "415929ab63f5314913c27d3dfdb965f2e76bedf2"
 }

package/src/Atlaspack.js

@@ -544,6 +544,10 @@ export default class Atlaspack {
     return this.#farm.takeHeapSnapshot();
   }
 
+  async unstable_invalidate(): Promise<void> {
+    await this._init();
+  }
+
   async unstable_transform(
     options: AtlaspackTransformOptions,
   ): Promise<Array<Asset>> {

package/src/RequestTracker.js

@@ -818,32 +818,59 @@ export class RequestGraph extends ContentGraph<
     node: FileNameNode,
     filePath: ProjectPath,
     matchNodes: Array<FileNode>,
+    invalidateNode: (NodeId, InvalidateReason) => void,
   ) {
     // If there is an edge between this file_name node and one of the original file nodes pointed to
     // by the original file_name node, and the matched node is inside the current directory, invalidate
     // all connected requests pointed to by the file node.
-    let dirname = path.dirname(fromProjectPathRelative(filePath));
 
     let nodeId = this.getNodeIdByContentKey(node.id);
-    for (let matchNode of matchNodes) {
-      let matchNodeId = this.getNodeIdByContentKey(matchNode.id);
-      if (
-        this.hasEdge(
-          nodeId,
-          matchNodeId,
-          requestGraphEdgeTypes.invalidated_by_create_above,
-        ) &&
-        isDirectoryInside(
-          fromProjectPathRelative(toProjectPathUnsafe(matchNode.id)),
-          dirname,
+    let dirname = path.dirname(fromProjectPathRelative(filePath));
+
+    if (getFeatureFlag('fixQuadraticCacheInvalidation')) {
+      while (dirname !== '/') {
+        if (!this.hasContentKey(dirname)) break;
+        const matchNodeId = this.getNodeIdByContentKey(dirname);
+        if (
+          !this.hasEdge(
+            nodeId,
+            matchNodeId,
+            requestGraphEdgeTypes.invalidated_by_create_above,
+          )
         )
-      ) {
-        let connectedNodes = this.getNodeIdsConnectedTo(
+          break;
+
+        const connectedNodes = this.getNodeIdsConnectedTo(
           matchNodeId,
           requestGraphEdgeTypes.invalidated_by_create,
         );
         for (let connectedNode of connectedNodes) {
-          this.invalidateNode(connectedNode, FILE_CREATE);
+          invalidateNode(connectedNode, FILE_CREATE);
+        }
+
+        dirname = path.dirname(dirname);
+      }
+    } else {
+      for (let matchNode of matchNodes) {
+        let matchNodeId = this.getNodeIdByContentKey(matchNode.id);
+        if (
+          this.hasEdge(
+            nodeId,
+            matchNodeId,
+            requestGraphEdgeTypes.invalidated_by_create_above,
+          ) &&
+          isDirectoryInside(
+            fromProjectPathRelative(toProjectPathUnsafe(matchNode.id)),
+            dirname,
+          )
+        ) {
+          let connectedNodes = this.getNodeIdsConnectedTo(
+            matchNodeId,
+            requestGraphEdgeTypes.invalidated_by_create,
+          );
+          for (let connectedNode of connectedNodes) {
+            this.invalidateNode(connectedNode, FILE_CREATE);
+          }
         }
       }
     }
@@ -866,6 +893,7 @@ export class RequestGraph extends ContentGraph<
           parent,
           toProjectPathUnsafe(dirname),
           matchNodes,
+          invalidateNode,
         );
       }
     }
@@ -880,10 +908,45 @@ export class RequestGraph extends ContentGraph<
     let count = 0;
     let predictedTime = 0;
     let startTime = Date.now();
-    const removeOrphans = !getFeatureFlag('fixQuadraticCacheInvalidation');
+    const enableOptimization = getFeatureFlag('fixQuadraticCacheInvalidation');
+    const removeOrphans = !enableOptimization;
+
+    const invalidatedNodes = new Set();
+    const invalidateNode = (nodeId, reason) => {
+      if (enableOptimization && invalidatedNodes.has(nodeId)) {
+        return;
+      }
+      invalidatedNodes.add(nodeId);
+      this.invalidateNode(nodeId, reason);
+    };
+    const aboveCache = new Map();
+    const getAbove = fileNameNodeId => {
+      const cachedResult = aboveCache.get(fileNameNodeId);
+      if (enableOptimization && cachedResult) {
+        return cachedResult;
+      }
+
+      let above = [];
+      const children = this.getNodeIdsConnectedTo(
+        fileNameNodeId,
+        requestGraphEdgeTypes.invalidated_by_create_above,
+      );
+      for (const nodeId of children) {
+        let node = nullthrows(this.getNode(nodeId));
+        if (node.type === FILE) {
+          above.push(node);
+        }
+      }
+      aboveCache.set(fileNameNodeId, above);
+      return above;
+    };
 
     for (let {path: _path, type} of events) {
-      if (++count === 256) {
+      if (
+        !enableOptimization &&
+        process.env.ATLASPACK_DISABLE_CACHE_TIMEOUT !== 'true' &&
+        ++count === 256
+      ) {
         let duration = Date.now() - startTime;
         predictedTime = duration * (events.length >> 8);
         if (predictedTime > threshold) {
@@ -939,7 +1002,7 @@ export class RequestGraph extends ContentGraph<
 
         for (let connectedNode of nodes) {
           didInvalidate = true;
-          this.invalidateNode(connectedNode, FILE_UPDATE);
+          invalidateNode(connectedNode, FILE_UPDATE);
         }
 
         if (type === 'create') {
@@ -949,7 +1012,7 @@ export class RequestGraph extends ContentGraph<
           );
           for (let connectedNode of nodes) {
             didInvalidate = true;
-            this.invalidateNode(connectedNode, FILE_CREATE);
+            invalidateNode(connectedNode, FILE_CREATE);
           }
         }
       } else if (type === 'create') {
@@ -961,21 +1024,15 @@ export class RequestGraph extends ContentGraph<
           );
 
           // Find potential file nodes to be invalidated if this file name pattern matches
-          let above: Array<FileNode> = [];
-          for (const nodeId of this.getNodeIdsConnectedTo(
-            fileNameNodeId,
-            requestGraphEdgeTypes.invalidated_by_create_above,
-          )) {
-            let node = nullthrows(this.getNode(nodeId));
-            // these might also be `glob` nodes which get handled below, we only care about files here.
-            if (node.type === FILE) {
-              above.push(node);
-            }
-          }
-
+          let above: Array<FileNode> = getAbove(fileNameNodeId);
           if (above.length > 0) {
             didInvalidate = true;
-            this.invalidateFileNameNode(fileNameNode, _filePath, above);
+            this.invalidateFileNameNode(
+              fileNameNode,
+              _filePath,
+              above,
+              invalidateNode,
+            );
           }
         }
 
@@ -990,7 +1047,7 @@ export class RequestGraph extends ContentGraph<
             );
             for (let connectedNode of connectedNodes) {
               didInvalidate = true;
-              this.invalidateNode(connectedNode, FILE_CREATE);
+              invalidateNode(connectedNode, FILE_CREATE);
             }
           }
         }
@@ -1001,7 +1058,7 @@ export class RequestGraph extends ContentGraph<
           requestGraphEdgeTypes.invalidated_by_delete,
         )) {
           didInvalidate = true;
-          this.invalidateNode(connectedNode, FILE_DELETE);
+          invalidateNode(connectedNode, FILE_DELETE);
         }
 
         // Delete the file node since it doesn't exist anymore.
@@ -1033,7 +1090,7 @@ export class RequestGraph extends ContentGraph<
               nodeId,
               requestGraphEdgeTypes.invalidated_by_update,
             )) {
-              this.invalidateNode(
+              invalidateNode(
                 connectedNode,
                 type === 'delete' ? FILE_DELETE : FILE_UPDATE,
               );
@@ -1057,6 +1114,8 @@ export class RequestGraph extends ContentGraph<
         trackableEvent: 'fsevent_response_time',
         duration,
         predictedTime,
+        numberOfEvents: events.length,
+        numberOfInvalidatedNodes: invalidatedNodes.size,
       },
     });
 
@@ -1615,6 +1674,15 @@ async function loadRequestGraph(options): Async<RequestGraph> {
   let timeout;
   const snapshotKey = `snapshot-${cacheKey}`;
   const snapshotPath = path.join(options.cacheDir, snapshotKey + '.txt');
+
+  logger.verbose({
+    origin: '@atlaspack/core',
+    message: 'Loading request graph',
+    meta: {
+      cacheKey,
+      snapshotKey,
+    },
+  });
   if (await options.cache.hasLargeBlob(requestGraphKey)) {
     try {
       let {requestGraph} = await readAndDeserializeRequestGraph(
@@ -1670,6 +1738,15 @@ async function loadRequestGraph(options): Async<RequestGraph> {
     }
   }
 
+  logger.verbose({
+    origin: '@atlaspack/core',
+    message:
+      'Cache entry for request tracker was not found, initializing a clean cache.',
+    meta: {
+      cacheKey,
+      snapshotKey,
+    },
+  });
   return new RequestGraph();
 }
 
@@ -1705,6 +1782,10 @@ function logErrorOnBailout(
 }
 
 export function cleanUpOrphans<N, E: number>(graph: Graph<N, E>): NodeId[] {
+  if (graph.rootNodeId == null) {
+    return [];
+  }
+
   const reachableNodes = new Set();
   graph.traverse(nodeId => {
     reachableNodes.add(nodeId);

package/test/RequestTracker.test.js

@@ -9,8 +9,10 @@ import RequestTracker, {
 import {Graph} from '@atlaspack/graph';
 import WorkerFarm from '@atlaspack/workers';
 import {DEFAULT_OPTIONS} from './test-utils';
-import {INITIAL_BUILD} from '../src/constants';
+import {FILE_CREATE, FILE_UPDATE, INITIAL_BUILD} from '../src/constants';
 import {makeDeferredWithPromise} from '@atlaspack/utils';
+import {toProjectPath} from '../src/projectPath';
+import {DEFAULT_FEATURE_FLAGS, setFeatureFlags} from '../../feature-flags/src';
 
 const options = DEFAULT_OPTIONS;
 const farm = new WorkerFarm({workerPath: require.resolve('../src/worker.js')});
@@ -449,6 +451,97 @@ describe('RequestTracker', () => {
 
     assert.equal(tracker.graph.getNode(nodeId)?.invalidateReason, 1);
   });
+
+  describe('respondToFSEvents', () => {
+    [true, false].forEach(value => {
+      beforeEach(() => {
+        setFeatureFlags({
+          ...DEFAULT_FEATURE_FLAGS,
+          fixQuadraticCacheInvalidation: value === true ? 'NEW' : 'OLD',
+        });
+      });
+
+      afterEach(() => {
+        setFeatureFlags({
+          ...DEFAULT_FEATURE_FLAGS,
+        });
+      });
+
+      describe(`optimizations feature-flag ${String(value)}`, () => {
+        it('should invalidate file requests on file changes', async () => {
+          let tracker = new RequestTracker({farm, options});
+          await tracker.runRequest({
+            id: 'abc',
+            type: 7,
+            // $FlowFixMe string isn't a valid result
+            run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+              api.invalidateOnFileUpdate(toProjectPath('', 'my-file'));
+              let result = await Promise.resolve('hello');
+              api.storeResult(result);
+            },
+            input: null,
+          });
+          const requestId = tracker.graph.getNodeIdByContentKey('abc');
+          const invalidated = await tracker.respondToFSEvents(
+            [
+              {
+                type: 'update',
+                path: 'my-file',
+              },
+            ],
+            Number.MAX_VALUE,
+          );
+          assert.equal(invalidated, true);
+          assert.equal(
+            tracker.graph.getNode(requestId)?.invalidateReason,
+            FILE_UPDATE,
+          );
+          assert.deepEqual(Array.from(tracker.graph.invalidNodeIds), [
+            requestId,
+          ]);
+        });
+
+        it('should invalidate file name requests with invalidate above invalidations', async () => {
+          let tracker = new RequestTracker({farm, options});
+          await tracker.runRequest({
+            id: 'abc',
+            type: 7,
+            // $FlowFixMe string isn't a valid result
+            run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+              api.invalidateOnFileCreate({
+                fileName: 'package.json',
+                aboveFilePath: toProjectPath(
+                  '',
+                  './node_modules/something/package.json',
+                ),
+              });
+              let result = await Promise.resolve('hello');
+              api.storeResult(result);
+            },
+            input: null,
+          });
+          const requestId = tracker.graph.getNodeIdByContentKey('abc');
+          const invalidated = await tracker.respondToFSEvents(
+            [
+              {
+                type: 'create',
+                path: './package.json',
+              },
+            ],
+            Number.MAX_VALUE,
+          );
+          assert.equal(invalidated, true);
+          assert.equal(
+            tracker.graph.getNode(requestId)?.invalidateReason,
+            FILE_CREATE,
+          );
+          assert.deepEqual(Array.from(tracker.graph.invalidNodeIds), [
+            requestId,
+          ]);
+        });
+      });
+    });
+  });
 });
 
 describe('cleanUpOrphans', () => {