@atlaspack/core 2.17.1 → 2.17.3

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # @atlaspack/core
 
+## 2.17.3
+
+### Patch Changes
+
+- [#551](https://github.com/atlassian-labs/atlaspack/pull/551) [`30f6017`](https://github.com/atlassian-labs/atlaspack/commit/30f60175ba4d272c5fc193973c63bc298584775b) Thanks [@yamadapc](https://github.com/yamadapc)! - Log request tracker invalidation counts on start-up
+
+- [#550](https://github.com/atlassian-labs/atlaspack/pull/550) [`3a3e8e7`](https://github.com/atlassian-labs/atlaspack/commit/3a3e8e7be9e2dffd7304436d792f0f595d59665a) Thanks [@yamadapc](https://github.com/yamadapc)! - Fix typescript declaration files
+
+- [#555](https://github.com/atlassian-labs/atlaspack/pull/555) [`15c1e3c`](https://github.com/atlassian-labs/atlaspack/commit/15c1e3c0628bae4c768d76cf3afc53d6d0d7ce7c) Thanks [@alshdavid](https://github.com/alshdavid)! - Added ATLASPACK_NATIVE_THREADS env variable to control the number of threads used by the native thread schedular
+
+- Updated dependencies [[`30f6017`](https://github.com/atlassian-labs/atlaspack/commit/30f60175ba4d272c5fc193973c63bc298584775b), [`3a3e8e7`](https://github.com/atlassian-labs/atlaspack/commit/3a3e8e7be9e2dffd7304436d792f0f595d59665a), [`1ab0a27`](https://github.com/atlassian-labs/atlaspack/commit/1ab0a275aeca40350415e2b03e7440d1dddc6228), [`b8a4ae8`](https://github.com/atlassian-labs/atlaspack/commit/b8a4ae8f83dc0a83d8b145c5f729936ce52080a3)]:
+  - @atlaspack/feature-flags@2.15.1
+  - @atlaspack/fs@2.15.3
+  - @atlaspack/rust@3.3.3
+  - @atlaspack/cache@3.2.3
+  - @atlaspack/graph@3.4.6
+  - @atlaspack/utils@2.14.8
+  - @atlaspack/package-manager@2.14.8
+  - @atlaspack/logger@2.14.8
+  - @atlaspack/profiler@2.14.6
+  - @atlaspack/types@2.14.8
+  - @atlaspack/workers@2.14.8
+  - @atlaspack/plugin@2.14.8
+
+## 2.17.2
+
+### Patch Changes
+
+- Updated dependencies [[`a1773d2`](https://github.com/atlassian-labs/atlaspack/commit/a1773d2a62d0ef7805ac7524621dcabcc1afe929), [`556d6ab`](https://github.com/atlassian-labs/atlaspack/commit/556d6ab8ede759fa7f37fcd3f4da336ef1c55e8f)]:
+  - @atlaspack/feature-flags@2.15.0
+  - @atlaspack/logger@2.14.7
+  - @atlaspack/rust@3.3.2
+  - @atlaspack/cache@3.2.2
+  - @atlaspack/fs@2.15.2
+  - @atlaspack/graph@3.4.5
+  - @atlaspack/utils@2.14.7
+  - @atlaspack/package-manager@2.14.7
+  - @atlaspack/workers@2.14.7
+  - @atlaspack/profiler@2.14.5
+  - @atlaspack/types@2.14.7
+  - @atlaspack/plugin@2.14.7
+
 ## 2.17.1
 
 ### Patch Changes

package/lib/Atlaspack.js

@@ -207,10 +207,16 @@ class Atlaspack {
       // $FlowFixMe
       const version = require('../package.json').version;
       await lmdb.put('current_session_version', Buffer.from(version));
+      let threads = undefined;
+      if (process.env.ATLASPACK_NATIVE_THREADS !== undefined) {
+        threads = parseInt(process.env.ATLASPACK_NATIVE_THREADS, 10);
+      } else if (process.env.NODE_ENV === 'test') {
+        threads = 2;
+      }
       rustAtlaspack = await _atlaspackV.AtlaspackV3.create({
         ...options,
         corePath: _path().default.join(__dirname, '..'),
-        threads: process.env.NODE_ENV === 'test' ? 2 : undefined,
+        threads,
         entries: Array.isArray(entries) ? entries : entries == null ? undefined : [entries],
         env: resolvedOptions.env,
         fs: inputFS && new _atlaspackV.FileSystemV3(inputFS),

package/lib/RequestTracker.js

@@ -279,6 +279,12 @@ class RequestGraph extends _graph().ContentGraph {
     // If the node is invalidated, the cached request chunk on disk needs to be re-written
     this.removeCachedRequestChunkForNode(nodeId);
   }
+
+  /**
+   * Nodes that are invalidated on start-up, such as JavaScript babel configuration files which are
+   * imported when the build kicks-off and might doing arbitrary work such as reading from the file
+   * system.
+   */
   invalidateUnpredictableNodes() {
     for (let nodeId of this.unpredicatableNodeIds) {
       let node = (0, _nullthrows().default)(this.getNode(nodeId));
@@ -286,6 +292,10 @@ class RequestGraph extends _graph().ContentGraph {
       this.invalidateNode(nodeId, _constants.STARTUP);
     }
   }
+
+  /**
+   * Effectively uncacheable nodes.
+   */
   invalidateOnBuildNodes() {
     for (let nodeId of this.invalidateOnBuildNodeIds) {
       let node = (0, _nullthrows().default)(this.getNode(nodeId));
@@ -293,29 +303,45 @@ class RequestGraph extends _graph().ContentGraph {
       this.invalidateNode(nodeId, _constants.STARTUP);
     }
   }
+
+  /**
+   * Nodes invalidated by environment changes, corresponds to `env: ...` inputs.
+   */
   invalidateEnvNodes(env) {
+    const invalidatedKeys = [];
     for (let nodeId of this.envNodeIds) {
       let node = (0, _nullthrows().default)(this.getNode(nodeId));
       (0, _assert().default)(node.type === ENV);
-      if (env[keyFromEnvContentKey(node.id)] !== node.value) {
+      const key = keyFromEnvContentKey(node.id);
+      if (env[key] !== node.value) {
+        invalidatedKeys.push(key);
         let parentNodes = this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_update);
         for (let parentNode of parentNodes) {
           this.invalidateNode(parentNode, _constants.ENV_CHANGE);
         }
       }
     }
+    return invalidatedKeys;
   }
+
+  /**
+   * Nodes invalidated by option changes.
+   */
   invalidateOptionNodes(options) {
+    const invalidatedKeys = [];
     for (let nodeId of this.optionNodeIds) {
       let node = (0, _nullthrows().default)(this.getNode(nodeId));
       (0, _assert().default)(node.type === OPTION);
-      if ((0, _utils2.hashFromOption)(options[keyFromOptionContentKey(node.id)]) !== node.hash) {
+      const key = keyFromOptionContentKey(node.id);
+      if ((0, _utils2.hashFromOption)(options[key]) !== node.hash) {
+        invalidatedKeys.push(key);
         let parentNodes = this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_update);
         for (let parentNode of parentNodes) {
           this.invalidateNode(parentNode, _constants.OPTION_CHANGE);
         }
       }
     }
+    return invalidatedKeys;
   }
   invalidateOnConfigKeyChange(requestNodeId, filePath, configKey, contentHash) {
     let configKeyNodeId = this.addNode(nodeFromConfigKey(filePath, configKey, contentHash));
@@ -1119,12 +1145,22 @@ async function loadRequestGraph(options) {
   let timeout;
   const snapshotKey = `snapshot-${cacheKey}`;
   const snapshotPath = _path2().default.join(options.cacheDir, snapshotKey + '.txt');
+  const commonMeta = {
+    cacheKey,
+    snapshotKey,
+    cacheKeyOptions: {
+      version: _constants.ATLASPACK_VERSION,
+      entries: options.entries,
+      mode: options.mode,
+      shouldBuildLazily: options.shouldBuildLazily,
+      watchBackend: options.watchBackend
+    }
+  };
   _logger().default.verbose({
     origin: '@atlaspack/core',
     message: 'Loading request graph',
     meta: {
-      cacheKey,
-      snapshotKey
+      ...commonMeta
     }
   });
   if (await options.cache.hasLargeBlob(requestGraphKey)) {
@@ -1146,16 +1182,29 @@ async function loadRequestGraph(options) {
         origin: '@atlaspack/core',
         message: `File system event count: ${events.length}`,
         meta: {
+          ...commonMeta,
           trackableEvent: 'watcher_events_count',
           watcherEventCount: events.length,
           duration: Date.now() - startTime
         }
       });
-      requestGraph.invalidateUnpredictableNodes();
-      requestGraph.invalidateOnBuildNodes();
-      requestGraph.invalidateEnvNodes(options.env);
-      requestGraph.invalidateOptionNodes(options);
-      await requestGraph.respondToFSEvents(options.unstableFileInvalidations || events, options, 10000, true);
+      if ((0, _featureFlags().getFeatureFlag)('verboseRequestInvalidationStats')) {
+        const invalidationStats = await invalidateRequestGraph(requestGraph, options, events);
+        _logger().default.verbose({
+          origin: '@atlaspack/core',
+          message: 'Request track loaded from cache',
+          meta: {
+            ...commonMeta,
+            trackableEvent: 'request_tracker_cache_key_hit',
+            invalidationStats
+          }
+        });
+      } else {
+        requestGraph.invalidateUnpredictableNodes();
+        requestGraph.invalidateOnBuildNodes();
+        requestGraph.invalidateEnvNodes(options.env);
+        requestGraph.invalidateOptionNodes(options);
+      }
       return requestGraph;
     } catch (e) {
       // Prevent logging fs events took too long warning
@@ -1170,12 +1219,76 @@ async function loadRequestGraph(options) {
     origin: '@atlaspack/core',
     message: 'Cache entry for request tracker was not found, initializing a clean cache.',
     meta: {
-      cacheKey,
-      snapshotKey
+      ...commonMeta,
+      trackableEvent: 'request_tracker_cache_key_miss'
     }
   });
   return new RequestGraph();
 }
+
+/**
+ * A wrapper around an invalidation type / method
+ */
+
+/**
+ * Information about a certain cache invalidation type.
+ */
+
+/**
+ * Respond to unpredictable, build, environment changes, option changes and file-system events
+ * invalidating RequestGraph nodes.
+ *
+ * Returns the count of nodes invalidated by each invalidation type.
+ */
+async function invalidateRequestGraph(requestGraph, options, events) {
+  const invalidationFns = [{
+    key: 'unpredictable',
+    fn: () => requestGraph.invalidateUnpredictableNodes()
+  }, {
+    key: 'onBuild',
+    fn: () => requestGraph.invalidateOnBuildNodes()
+  }, {
+    key: 'env',
+    fn: () => requestGraph.invalidateEnvNodes(options.env)
+  }, {
+    key: 'option',
+    fn: () => requestGraph.invalidateOptionNodes(options)
+  }, {
+    key: 'fsEvents',
+    fn: async () => {
+      await requestGraph.respondToFSEvents(options.unstableFileInvalidations || events, options, 10000, true);
+    }
+  }];
+  const invalidations = [];
+  for (const invalidation of invalidationFns) {
+    invalidations.push(await runInvalidation(requestGraph, invalidation));
+  }
+  const invalidatedCount = invalidations.reduce((acc, invalidation) => acc + invalidation.count, 0);
+  const requestCount = requestGraph.nodes.reduce((acc, node) => acc + ((node === null || node === void 0 ? void 0 : node.type) === REQUEST ? 1 : 0), 0);
+  const nodeCount = requestGraph.nodes.length;
+  return {
+    invalidations,
+    nodeCount,
+    requestCount,
+    invalidatedCount,
+    nodeInvalidationRatio: invalidatedCount / nodeCount,
+    requestInvalidationRatio: invalidatedCount / requestCount
+  };
+}
+
+/**
+ * Runs an invalidation function and reports metrics.
+ */
+async function runInvalidation(requestGraph, invalidationFn) {
+  const startInvalidationCount = requestGraph.invalidNodeIds.size;
+  const result = await invalidationFn.fn();
+  const count = requestGraph.invalidNodeIds.size - startInvalidationCount;
+  return {
+    key: invalidationFn.key,
+    count,
+    changes: typeof result === 'object' && Array.isArray(result) ? result : null
+  };
+}
 function logErrorOnBailout(options, snapshotPath, e) {
   if (e.message && e.message.includes('invalid clockspec')) {
     const snapshotContents = options.inputFS.readFileSync(snapshotPath, 'utf-8');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.17.1",
+  "version": "2.17.3",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -10,6 +10,7 @@
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
   "main": "lib/index.js",
+  "types": "index.d.ts",
   "source": "src/index.js",
   "engines": {
     "node": ">= 16.0.0"
@@ -22,20 +23,20 @@
   "dependencies": {
     "@mischnic/json-sourcemap": "^0.1.0",
     "@atlaspack/build-cache": "2.13.3",
-    "@atlaspack/cache": "3.2.1",
+    "@atlaspack/cache": "3.2.3",
     "@atlaspack/diagnostic": "2.14.1",
     "@atlaspack/events": "2.14.1",
-    "@atlaspack/feature-flags": "2.14.4",
-    "@atlaspack/fs": "2.15.1",
-    "@atlaspack/graph": "3.4.4",
-    "@atlaspack/logger": "2.14.6",
-    "@atlaspack/package-manager": "2.14.6",
-    "@atlaspack/plugin": "2.14.6",
-    "@atlaspack/profiler": "2.14.4",
-    "@atlaspack/rust": "3.3.1",
-    "@atlaspack/types": "2.14.6",
-    "@atlaspack/utils": "2.14.6",
-    "@atlaspack/workers": "2.14.6",
+    "@atlaspack/feature-flags": "2.15.1",
+    "@atlaspack/fs": "2.15.3",
+    "@atlaspack/graph": "3.4.6",
+    "@atlaspack/logger": "2.14.8",
+    "@atlaspack/package-manager": "2.14.8",
+    "@atlaspack/plugin": "2.14.8",
+    "@atlaspack/profiler": "2.14.6",
+    "@atlaspack/rust": "3.3.3",
+    "@atlaspack/types": "2.14.8",
+    "@atlaspack/utils": "2.14.8",
+    "@atlaspack/workers": "2.14.8",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
@@ -57,7 +58,10 @@
   },
   "exports": {
     "./*": "./*",
-    ".": "./lib/index.js",
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./lib/index.js"
+    },
     "./worker": {
       "@atlaspack::sources": "./src/worker.js",
       "default": "./lib/worker.js"

package/src/Atlaspack.js

@@ -165,10 +165,17 @@ export default class Atlaspack {
       const version = require('../package.json').version;
       await lmdb.put('current_session_version', Buffer.from(version));
 
+      let threads = undefined;
+      if (process.env.ATLASPACK_NATIVE_THREADS !== undefined) {
+        threads = parseInt(process.env.ATLASPACK_NATIVE_THREADS, 10);
+      } else if (process.env.NODE_ENV === 'test') {
+        threads = 2;
+      }
+
       rustAtlaspack = await AtlaspackV3.create({
         ...options,
         corePath: path.join(__dirname, '..'),
-        threads: process.env.NODE_ENV === 'test' ? 2 : undefined,
+        threads,
         entries: Array.isArray(entries)
           ? entries
           : entries == null

package/src/RequestTracker.js

@@ -446,6 +446,11 @@ export class RequestGraph extends ContentGraph<
     this.removeCachedRequestChunkForNode(nodeId);
   }
 
+  /**
+   * Nodes that are invalidated on start-up, such as JavaScript babel configuration files which are
+   * imported when the build kicks-off and might doing arbitrary work such as reading from the file
+   * system.
+   */
   invalidateUnpredictableNodes() {
     for (let nodeId of this.unpredicatableNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
@@ -454,6 +459,9 @@ export class RequestGraph extends ContentGraph<
     }
   }
 
+  /**
+   * Effectively uncacheable nodes.
+   */
   invalidateOnBuildNodes() {
     for (let nodeId of this.invalidateOnBuildNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
@@ -462,11 +470,20 @@ export class RequestGraph extends ContentGraph<
     }
   }
 
-  invalidateEnvNodes(env: EnvMap) {
+  /**
+   * Nodes invalidated by environment changes, corresponds to `env: ...` inputs.
+   */
+  invalidateEnvNodes(env: EnvMap): string[] {
+    const invalidatedKeys = [];
+
     for (let nodeId of this.envNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
       invariant(node.type === ENV);
-      if (env[keyFromEnvContentKey(node.id)] !== node.value) {
+
+      const key = keyFromEnvContentKey(node.id);
+      if (env[key] !== node.value) {
+        invalidatedKeys.push(key);
+
         let parentNodes = this.getNodeIdsConnectedTo(
           nodeId,
           requestGraphEdgeTypes.invalidated_by_update,
@@ -476,15 +493,23 @@ export class RequestGraph extends ContentGraph<
         }
       }
     }
+
+    return invalidatedKeys;
   }
 
-  invalidateOptionNodes(options: AtlaspackOptions) {
+  /**
+   * Nodes invalidated by option changes.
+   */
+  invalidateOptionNodes(options: AtlaspackOptions): string[] {
+    const invalidatedKeys = [];
+
     for (let nodeId of this.optionNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
       invariant(node.type === OPTION);
-      if (
-        hashFromOption(options[keyFromOptionContentKey(node.id)]) !== node.hash
-      ) {
+      const key = keyFromOptionContentKey(node.id);
+
+      if (hashFromOption(options[key]) !== node.hash) {
+        invalidatedKeys.push(key);
         let parentNodes = this.getNodeIdsConnectedTo(
           nodeId,
           requestGraphEdgeTypes.invalidated_by_update,
@@ -494,6 +519,8 @@ export class RequestGraph extends ContentGraph<
         }
       }
     }
+
+    return invalidatedKeys;
   }
 
   invalidateOnConfigKeyChange(
@@ -1727,12 +1754,23 @@ async function loadRequestGraph(options): Async<RequestGraph> {
   const snapshotKey = `snapshot-${cacheKey}`;
   const snapshotPath = path.join(options.cacheDir, snapshotKey + '.txt');
 
+  const commonMeta = {
+    cacheKey,
+    snapshotKey,
+    cacheKeyOptions: {
+      version: ATLASPACK_VERSION,
+      entries: options.entries,
+      mode: options.mode,
+      shouldBuildLazily: options.shouldBuildLazily,
+      watchBackend: options.watchBackend,
+    },
+  };
+
   logger.verbose({
     origin: '@atlaspack/core',
     message: 'Loading request graph',
     meta: {
-      cacheKey,
-      snapshotKey,
+      ...commonMeta,
     },
   });
 
@@ -1767,23 +1805,36 @@ async function loadRequestGraph(options): Async<RequestGraph> {
         origin: '@atlaspack/core',
         message: `File system event count: ${events.length}`,
         meta: {
+          ...commonMeta,
           trackableEvent: 'watcher_events_count',
           watcherEventCount: events.length,
           duration: Date.now() - startTime,
         },
       });
 
-      requestGraph.invalidateUnpredictableNodes();
-      requestGraph.invalidateOnBuildNodes();
-      requestGraph.invalidateEnvNodes(options.env);
-      requestGraph.invalidateOptionNodes(options);
+      if (getFeatureFlag('verboseRequestInvalidationStats')) {
+        const invalidationStats = await invalidateRequestGraph(
+          requestGraph,
+          options,
+          events,
+        );
+
+        logger.verbose({
+          origin: '@atlaspack/core',
+          message: 'Request track loaded from cache',
+          meta: {
+            ...commonMeta,
+            trackableEvent: 'request_tracker_cache_key_hit',
+            invalidationStats,
+          },
+        });
+      } else {
+        requestGraph.invalidateUnpredictableNodes();
+        requestGraph.invalidateOnBuildNodes();
+        requestGraph.invalidateEnvNodes(options.env);
+        requestGraph.invalidateOptionNodes(options);
+      }
 
-      await requestGraph.respondToFSEvents(
-        options.unstableFileInvalidations || events,
-        options,
-        10000,
-        true,
-      );
       return requestGraph;
     } catch (e) {
       // Prevent logging fs events took too long warning
@@ -1800,13 +1851,158 @@ async function loadRequestGraph(options): Async<RequestGraph> {
     message:
       'Cache entry for request tracker was not found, initializing a clean cache.',
     meta: {
-      cacheKey,
-      snapshotKey,
+      ...commonMeta,
+      trackableEvent: 'request_tracker_cache_key_miss',
     },
   });
   return new RequestGraph();
 }
 
+/**
+ * A wrapper around an invalidation type / method
+ */
+type InvalidationFn = {|
+  key: string,
+  fn: () => string[] | void | Promise<void>,
+|};
+
+type InvalidationStats = {|
+  /**
+   * Total number of request graph nodes
+   */
+  nodeCount: number,
+  /**
+   * Number of requests in RequestGraph
+   */
+  requestCount: number,
+  /**
+   * Number of nodes that have been invalidated.
+   */
+  invalidatedCount: number,
+  /**
+   * Percentage of requests that have been invalidated
+   */
+  requestInvalidationRatio: number,
+  /**
+   * Percentage of nodes that have been invalidated
+   */
+  nodeInvalidationRatio: number,
+  /**
+   * Details for each invalidation type
+   */
+  invalidations: InvalidationFnStats[],
+|};
+
+/**
+ * Information about a certain cache invalidation type.
+ */
+type InvalidationFnStats = {|
+  /**
+   * Invalidation type, one of:
+   *
+   * - unpredictable
+   * - onBuild
+   * - env
+   * - option
+   * - fsEvents
+   */
+  key: string,
+  /**
+   * Number of invalidated nodes coming from this invalidation type.
+   */
+  count: number,
+  /**
+   * If this is a env or option invalidation, this key will contain the list of changed values.
+   */
+  changes: null | string[],
+|};
+
+/**
+ * Respond to unpredictable, build, environment changes, option changes and file-system events
+ * invalidating RequestGraph nodes.
+ *
+ * Returns the count of nodes invalidated by each invalidation type.
+ */
+async function invalidateRequestGraph(
+  requestGraph: RequestGraph,
+  options: AtlaspackOptions,
+  events: Event[],
+): Promise<InvalidationStats> {
+  const invalidationFns: InvalidationFn[] = [
+    {
+      key: 'unpredictable',
+      fn: () => requestGraph.invalidateUnpredictableNodes(),
+    },
+    {
+      key: 'onBuild',
+      fn: () => requestGraph.invalidateOnBuildNodes(),
+    },
+    {
+      key: 'env',
+      fn: () => requestGraph.invalidateEnvNodes(options.env),
+    },
+    {
+      key: 'option',
+      fn: () => requestGraph.invalidateOptionNodes(options),
+    },
+    {
+      key: 'fsEvents',
+      fn: async () => {
+        await requestGraph.respondToFSEvents(
+          options.unstableFileInvalidations || events,
+          options,
+          10000,
+          true,
+        );
+      },
+    },
+  ];
+
+  const invalidations = [];
+  for (const invalidation of invalidationFns) {
+    invalidations.push(await runInvalidation(requestGraph, invalidation));
+  }
+  const invalidatedCount = invalidations.reduce(
+    (acc, invalidation) => acc + invalidation.count,
+    0,
+  );
+  const requestCount = requestGraph.nodes.reduce(
+    (acc, node) => acc + (node?.type === REQUEST ? 1 : 0),
+    0,
+  );
+  const nodeCount = requestGraph.nodes.length;
+  const nodeInvalidationRatio = invalidatedCount / nodeCount;
+  const requestInvalidationRatio = invalidatedCount / requestCount;
+
+  return {
+    invalidations,
+    nodeCount,
+    requestCount,
+    invalidatedCount,
+    nodeInvalidationRatio,
+    requestInvalidationRatio,
+  };
+}
+
+/**
+ * Runs an invalidation function and reports metrics.
+ */
+async function runInvalidation(
+  requestGraph: RequestGraph,
+  invalidationFn: InvalidationFn,
+): Promise<InvalidationFnStats> {
+  const startInvalidationCount = requestGraph.invalidNodeIds.size;
+  const result = await invalidationFn.fn();
+  const count = requestGraph.invalidNodeIds.size - startInvalidationCount;
+
+  return {
+    key: invalidationFn.key,
+    count,
+    changes:
+      typeof result === 'object' && Array.isArray(result) ? result : null,
+  };
+}
+
 function logErrorOnBailout(
   options: AtlaspackOptions,
   snapshotPath: string,