@atlaspack/core 2.16.2-canary.57 → 2.16.2-canary.58

package/lib/RequestTracker.js

@@ -162,7 +162,7 @@ const nodeFromOption = (option, value) => ({
   hash: (0, _utils2.hashFromOption)(value)
 });
 const nodeFromConfigKey = (fileName, configKey, contentHash) => ({
-  id: `config_key:${(0, _projectPath.fromProjectPathRelative)(fileName)}:${configKey}`,
+  id: `config_key:${(0, _projectPath.fromProjectPathRelative)(fileName)}:${JSON.stringify(configKey)}`,
   type: CONFIG_KEY,
   configKey,
   contentHash
@@ -695,10 +695,18 @@ class RequestGraph extends _graph().ContentGraph {
         this.removeNode(nodeId, removeOrphans);
       }
       let configKeyNodes = this.configKeyNodes.get(_filePath);
-      if (configKeyNodes && (type === 'delete' || type === 'update')) {
+
+      // With granular invalidations we will always run this block,
+      // so even if we get a create event (for whatever reason), we will still
+      // try to limit invalidations from config key changes through hashing.
+      //
+      // Currently create events can invalidate a large number of nodes due to
+      // "create above" invalidations.
+      const isConfigKeyChange = (0, _featureFlags().getFeatureFlag)('granularTsConfigInvalidation') || type === 'delete' || type === 'update';
+      if (configKeyNodes && isConfigKeyChange) {
         for (let nodeId of configKeyNodes) {
           let isInvalid = type === 'delete';
-          if (type === 'update') {
+          if (type !== 'delete') {
             let node = this.getNode(nodeId);
             (0, _assert().default)(node && node.type === CONFIG_KEY);
             let contentHash = await (0, _ConfigRequest.getConfigKeyContentHash)(_filePath, node.configKey, options);

package/lib/public/Config.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+exports.makeConfigProxy = makeConfigProxy;
 function _assert() {
   const data = _interopRequireDefault(require("assert"));
   _assert = function () {
@@ -37,6 +38,71 @@ function _featureFlags() {
 var _EnvironmentManager = require("../EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const internalConfigToConfig = new (_utils().DefaultWeakMap)(() => new WeakMap());
+
+/**
+ * Implements read tracking over an object.
+ *
+ * Calling this function with a non-trivial object like a class instance will fail to work.
+ *
+ * We track reads to fields that resolve to:
+ *
+ * - primitive values
+ * - arrays
+ *
+ * That is, reading a nested field `a.b.c` will make a single call to `onRead` with the path
+ * `['a', 'b', 'c']`.
+ *
+ * In case the value is null or an array, we will track the read as well.
+ *
+ * Iterating over `Object.keys(obj.field)` will register a read for the `['field']` path.
+ * Other reads work normally.
+ *
+ * @example
+ *
+ *     const usedPaths = new Set();
+ *     const onRead = (path) => {
+ *        usedPaths.add(path);
+ *     };
+ *
+ *     const config = makeConfigProxy(onRead, {a: {b: {c: 'd'}}})
+ *     console.log(config.a.b.c);
+ *     console.log(Array.from(usedPaths));
+ *     // We get a single read for the path
+ *     // ['a', 'b', 'c']
+ *
+ */
+function makeConfigProxy(onRead, config) {
+  const reportedPaths = new Set();
+  const reportPath = path => {
+    if (reportedPaths.has(path)) {
+      return;
+    }
+    reportedPaths.add(path);
+    onRead(path);
+  };
+  const makeProxy = (target, path) => {
+    return new Proxy(target, {
+      ownKeys(target) {
+        reportPath(path);
+
+        // $FlowFixMe
+        return Object.getOwnPropertyNames(target);
+      },
+      get(target, prop) {
+        // $FlowFixMe
+        const value = target[prop];
+        if (typeof value === 'object' && value != null && !Array.isArray(value)) {
+          return makeProxy(value, [...path, prop]);
+        }
+        reportPath([...path, prop]);
+        return value;
+      }
+    });
+  };
+
+  // $FlowFixMe
+  return makeProxy(config, []);
+}
 class PublicConfig {
   #config /*: Config */;
   #pkg /*: ?PackageJSON */;
@@ -127,32 +193,30 @@ class PublicConfig {
       });
       if (pkg && pkg.contents[packageKey]) {
         // Invalidate only when the package key changes
-        this.invalidateOnConfigKeyChange(pkg.filePath, packageKey);
+        this.invalidateOnConfigKeyChange(pkg.filePath, [packageKey]);
         return {
           contents: pkg.contents[packageKey],
           filePath: pkg.filePath
         };
       }
     }
-    if ((0, _featureFlags().getFeatureFlag)('granularTsConfigInvalidation')) {
-      const configKey = options === null || options === void 0 ? void 0 : options.configKey;
-      if (configKey != null) {
-        for (let fileName of fileNames) {
-          let config = await this.getConfigFrom(searchPath, [fileName], {
-            exclude: true
+    const readTracking = options === null || options === void 0 ? void 0 : options.readTracking;
+    if (readTracking === true) {
+      for (let fileName of fileNames) {
+        const config = await this.getConfigFrom(searchPath, [fileName], {
+          exclude: true
+        });
+        if (config != null) {
+          return Promise.resolve({
+            contents: makeConfigProxy(keyPath => {
+              this.invalidateOnConfigKeyChange(config.filePath, keyPath);
+            }, config.contents),
+            filePath: config.filePath
           });
-          if (config && config.contents[configKey]) {
-            // Invalidate only when the package key changes
-            this.invalidateOnConfigKeyChange(config.filePath, configKey);
-            return {
-              contents: config.contents[configKey],
-              filePath: config.filePath
-            };
-          }
         }
-
-        // fall through so that file above invalidations are registered
       }
+
+      // fall through so that file above invalidations are registered
     }
 
     if (fileNames.length === 0) {
@@ -219,7 +283,9 @@ class PublicConfig {
     if (this.#pkg) {
       return this.#pkg;
     }
-    let pkgConfig = await this.getConfig(['package.json']);
+    let pkgConfig = await this.getConfig(['package.json'], {
+      readTracking: (0, _featureFlags().getFeatureFlag)('granularTsConfigInvalidation')
+    });
     if (!pkgConfig) {
       return null;
     }

package/lib/requests/ConfigRequest.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.getConfigHash = getConfigHash;
 exports.getConfigKeyContentHash = getConfigKeyContentHash;
 exports.getConfigRequests = getConfigRequests;
+exports.getValueAtPath = getValueAtPath;
 exports.loadPluginConfig = loadPluginConfig;
 exports.runConfigRequest = runConfigRequest;
 function _utils() {
@@ -86,19 +87,41 @@ async function loadPluginConfig(loadedPlugin, config, options) {
     });
   }
 }
+
+/**
+ * Return value at a given key path within an object.
+ *
+ * @example
+ *     const obj = { a: { b: { c: 'd' } } };
+ *     getValueAtPath(obj, ['a', 'b', 'c']);        // 'd'
+ *     getValueAtPath(obj, ['a', 'b', 'd']);        // undefined
+ *     getValueAtPath(obj, ['a', 'b']);             // { c: 'd' }
+ *     getValueAtPath(obj, ['a', 'b', 'c', 'd']);   // undefined
+ */
+function getValueAtPath(obj, key) {
+  let current = obj;
+  for (let part of key) {
+    if (current == null) {
+      return undefined;
+    }
+    current = current[part];
+  }
+  return current;
+}
 const configKeyCache = (0, _buildCache().createBuildCache)();
 async function getConfigKeyContentHash(filePath, configKey, options) {
-  let cacheKey = `${(0, _projectPath.fromProjectPathRelative)(filePath)}:${configKey}`;
+  let cacheKey = `${(0, _projectPath.fromProjectPathRelative)(filePath)}:${JSON.stringify(configKey)}`;
   let cachedValue = configKeyCache.get(cacheKey);
   if (cachedValue) {
     return cachedValue;
   }
-  let conf = await (0, _utils().readConfig)(options.inputFS, (0, _projectPath.fromProjectPath)(options.projectRoot, filePath));
-  if (conf == null || conf.config[configKey] == null) {
+  const conf = await (0, _utils().readConfig)(options.inputFS, (0, _projectPath.fromProjectPath)(options.projectRoot, filePath));
+  const value = getValueAtPath(conf === null || conf === void 0 ? void 0 : conf.config, configKey);
+  if (conf == null || value == null) {
     // This can occur when a config key has been removed entirely during `respondToFSEvents`
     return '';
   }
-  let contentHash = typeof conf.config[configKey] === 'object' ? (0, _utils().hashObject)(conf.config[configKey]) : (0, _rust().hashString)(JSON.stringify(conf.config[configKey]));
+  const contentHash = typeof value === 'object' ? (0, _utils().hashObject)(value) : (0, _rust().hashString)(JSON.stringify(value));
   configKeyCache.set(cacheKey, contentHash);
   return contentHash;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.16.2-canary.57+6dd4ccb75",
+  "version": "2.16.2-canary.58+1e32d4eae",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -21,21 +21,21 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3-canary.125+6dd4ccb75",
-    "@atlaspack/cache": "3.1.1-canary.57+6dd4ccb75",
-    "@atlaspack/diagnostic": "2.14.1-canary.125+6dd4ccb75",
-    "@atlaspack/events": "2.14.1-canary.125+6dd4ccb75",
-    "@atlaspack/feature-flags": "2.14.1-canary.125+6dd4ccb75",
-    "@atlaspack/fs": "2.14.5-canary.57+6dd4ccb75",
-    "@atlaspack/graph": "3.4.1-canary.125+6dd4ccb75",
-    "@atlaspack/logger": "2.14.5-canary.57+6dd4ccb75",
-    "@atlaspack/package-manager": "2.14.5-canary.57+6dd4ccb75",
-    "@atlaspack/plugin": "2.14.5-canary.57+6dd4ccb75",
-    "@atlaspack/profiler": "2.14.1-canary.125+6dd4ccb75",
-    "@atlaspack/rust": "3.2.1-canary.57+6dd4ccb75",
-    "@atlaspack/types": "2.14.5-canary.57+6dd4ccb75",
-    "@atlaspack/utils": "2.14.5-canary.57+6dd4ccb75",
-    "@atlaspack/workers": "2.14.5-canary.57+6dd4ccb75",
+    "@atlaspack/build-cache": "2.13.3-canary.126+1e32d4eae",
+    "@atlaspack/cache": "3.1.1-canary.58+1e32d4eae",
+    "@atlaspack/diagnostic": "2.14.1-canary.126+1e32d4eae",
+    "@atlaspack/events": "2.14.1-canary.126+1e32d4eae",
+    "@atlaspack/feature-flags": "2.14.1-canary.126+1e32d4eae",
+    "@atlaspack/fs": "2.14.5-canary.58+1e32d4eae",
+    "@atlaspack/graph": "3.4.1-canary.126+1e32d4eae",
+    "@atlaspack/logger": "2.14.5-canary.58+1e32d4eae",
+    "@atlaspack/package-manager": "2.14.5-canary.58+1e32d4eae",
+    "@atlaspack/plugin": "2.14.5-canary.58+1e32d4eae",
+    "@atlaspack/profiler": "2.14.1-canary.126+1e32d4eae",
+    "@atlaspack/rust": "3.2.1-canary.58+1e32d4eae",
+    "@atlaspack/types": "2.14.5-canary.58+1e32d4eae",
+    "@atlaspack/utils": "2.14.5-canary.58+1e32d4eae",
+    "@atlaspack/workers": "2.14.5-canary.58+1e32d4eae",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -71,5 +71,5 @@
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
   "type": "commonjs",
-  "gitHead": "6dd4ccb753541de32322d881f973d571dd57e4ca"
+  "gitHead": "1e32d4eae6b3af3968e8a0ef97d35b4347fd4196"
 }

package/src/InternalConfig.js

@@ -24,7 +24,7 @@ type ConfigOpts = {|
   invalidateOnFileChange?: Set<ProjectPath>,
   invalidateOnConfigKeyChange?: Array<{|
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
   |}>,
   invalidateOnFileCreate?: Array<InternalFileCreateInvalidation>,
   invalidateOnEnvChange?: Set<string>,

package/src/RequestTracker.js

@@ -144,7 +144,7 @@ type OptionNode = {|
 type ConfigKeyNode = {|
   id: ContentKey,
   +type: typeof CONFIG_KEY,
-  configKey: string,
+  configKey: string[],
   contentHash: string,
 |};
 
@@ -216,7 +216,7 @@ export type RunAPI<TResult: RequestResult> = {|
   invalidateOnFileUpdate: (ProjectPath) => void,
   invalidateOnConfigKeyChange: (
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
     contentHash: string,
   ) => void,
   invalidateOnStartup: () => void,
@@ -283,10 +283,12 @@ const nodeFromOption = (option: string, value: mixed): RequestGraphNode => ({
 
 const nodeFromConfigKey = (
   fileName: ProjectPath,
-  configKey: string,
+  configKey: string[],
   contentHash: string,
 ): RequestGraphNode => ({
-  id: `config_key:${fromProjectPathRelative(fileName)}:${configKey}`,
+  id: `config_key:${fromProjectPathRelative(fileName)}:${JSON.stringify(
+    configKey,
+  )}`,
   type: CONFIG_KEY,
   configKey,
   contentHash,
@@ -527,7 +529,7 @@ export class RequestGraph extends ContentGraph<
   invalidateOnConfigKeyChange(
     requestNodeId: NodeId,
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
     contentHash: string,
   ) {
     let configKeyNodeId = this.addNode(
@@ -1109,11 +1111,22 @@ export class RequestGraph extends ContentGraph<
       }
 
       let configKeyNodes = this.configKeyNodes.get(_filePath);
-      if (configKeyNodes && (type === 'delete' || type === 'update')) {
+
+      // With granular invalidations we will always run this block,
+      // so even if we get a create event (for whatever reason), we will still
+      // try to limit invalidations from config key changes through hashing.
+      //
+      // Currently create events can invalidate a large number of nodes due to
+      // "create above" invalidations.
+      const isConfigKeyChange =
+        getFeatureFlag('granularTsConfigInvalidation') ||
+        type === 'delete' ||
+        type === 'update';
+      if (configKeyNodes && isConfigKeyChange) {
         for (let nodeId of configKeyNodes) {
           let isInvalid = type === 'delete';
 
-          if (type === 'update') {
+          if (type !== 'delete') {
             let node = this.getNode(nodeId);
             invariant(node && node.type === CONFIG_KEY);
 

package/src/atlaspack-v3/worker/compat/plugin-config.js

@@ -107,7 +107,7 @@ export class PluginConfig implements IPluginConfig {
           exclude?: boolean,
         |}
       | {|
-          configKey?: string,
+          readTracking?: boolean,
         |},
   ): Promise<?ConfigResultWithFilePath<T>> {
     return this.#inner.getConfigFrom(searchPath, filePaths, options);

package/src/public/Config.js

@@ -28,6 +28,82 @@ const internalConfigToConfig: DefaultWeakMap<
   WeakMap<Config, PublicConfig>,
 > = new DefaultWeakMap(() => new WeakMap());
 
+/**
+ * Implements read tracking over an object.
+ *
+ * Calling this function with a non-trivial object like a class instance will fail to work.
+ *
+ * We track reads to fields that resolve to:
+ *
+ * - primitive values
+ * - arrays
+ *
+ * That is, reading a nested field `a.b.c` will make a single call to `onRead` with the path
+ * `['a', 'b', 'c']`.
+ *
+ * In case the value is null or an array, we will track the read as well.
+ *
+ * Iterating over `Object.keys(obj.field)` will register a read for the `['field']` path.
+ * Other reads work normally.
+ *
+ * @example
+ *
+ *     const usedPaths = new Set();
+ *     const onRead = (path) => {
+ *        usedPaths.add(path);
+ *     };
+ *
+ *     const config = makeConfigProxy(onRead, {a: {b: {c: 'd'}}})
+ *     console.log(config.a.b.c);
+ *     console.log(Array.from(usedPaths));
+ *     // We get a single read for the path
+ *     // ['a', 'b', 'c']
+ *
+ */
+export function makeConfigProxy<T>(
+  onRead: (path: string[]) => void,
+  config: T,
+): T {
+  const reportedPaths = new Set();
+  const reportPath = (path) => {
+    if (reportedPaths.has(path)) {
+      return;
+    }
+    reportedPaths.add(path);
+    onRead(path);
+  };
+
+  const makeProxy = (target, path) => {
+    return new Proxy(target, {
+      ownKeys(target) {
+        reportPath(path);
+
+        // $FlowFixMe
+        return Object.getOwnPropertyNames(target);
+      },
+      get(target, prop) {
+        // $FlowFixMe
+        const value = target[prop];
+
+        if (
+          typeof value === 'object' &&
+          value != null &&
+          !Array.isArray(value)
+        ) {
+          return makeProxy(value, [...path, prop]);
+        }
+
+        reportPath([...path, prop]);
+
+        return value;
+      },
+    });
+  };
+
+  // $FlowFixMe
+  return makeProxy(config, []);
+}
+
 export default class PublicConfig implements IConfig {
   #config /*: Config */;
   #pkg /*: ?PackageJSON */;
@@ -77,7 +153,7 @@ export default class PublicConfig implements IConfig {
     );
   }
 
-  invalidateOnConfigKeyChange(filePath: FilePath, configKey: string) {
+  invalidateOnConfigKeyChange(filePath: FilePath, configKey: string[]) {
     this.#config.invalidateOnConfigKeyChange.push({
       filePath: toProjectPath(this.#options.projectRoot, filePath),
       configKey,
@@ -145,9 +221,10 @@ export default class PublicConfig implements IConfig {
         |}
       | ?{|
           /**
-           * If specified, only invalidate when this config key changes.
+           * If specified, this function will return a proxy object that will track reads to
+           * config fields and only register invalidations for when those keys change.
            */
-          configKey?: string,
+          readTracking?: boolean,
         |},
   ): Promise<?ConfigResultWithFilePath<T>> {
     let packageKey = options?.packageKey;
@@ -158,7 +235,7 @@ export default class PublicConfig implements IConfig {
 
       if (pkg && pkg.contents[packageKey]) {
         // Invalidate only when the package key changes
-        this.invalidateOnConfigKeyChange(pkg.filePath, packageKey);
+        this.invalidateOnConfigKeyChange(pkg.filePath, [packageKey]);
 
         return {
           contents: pkg.contents[packageKey],
@@ -167,27 +244,24 @@ export default class PublicConfig implements IConfig {
       }
     }
 
-    if (getFeatureFlag('granularTsConfigInvalidation')) {
-      const configKey = options?.configKey;
-      if (configKey != null) {
-        for (let fileName of fileNames) {
-          let config = await this.getConfigFrom(searchPath, [fileName], {
-            exclude: true,
+    const readTracking = options?.readTracking;
+    if (readTracking === true) {
+      for (let fileName of fileNames) {
+        const config = await this.getConfigFrom(searchPath, [fileName], {
+          exclude: true,
+        });
+
+        if (config != null) {
+          return Promise.resolve({
+            contents: makeConfigProxy((keyPath) => {
+              this.invalidateOnConfigKeyChange(config.filePath, keyPath);
+            }, config.contents),
+            filePath: config.filePath,
           });
-
-          if (config && config.contents[configKey]) {
-            // Invalidate only when the package key changes
-            this.invalidateOnConfigKeyChange(config.filePath, configKey);
-
-            return {
-              contents: config.contents[configKey],
-              filePath: config.filePath,
-            };
-          }
         }
-
-        // fall through so that file above invalidations are registered
       }
+
+      // fall through so that file above invalidations are registered
     }
 
     if (fileNames.length === 0) {
@@ -269,11 +343,15 @@ export default class PublicConfig implements IConfig {
 
   getConfig<T>(
     filePaths: Array<FilePath>,
-    options: ?{|
-      packageKey?: string,
-      parse?: boolean,
-      exclude?: boolean,
-    |},
+    options:
+      | ?{|
+          packageKey?: string,
+          parse?: boolean,
+          exclude?: boolean,
+        |}
+      | {|
+          readTracking?: boolean,
+        |},
   ): Promise<?ConfigResultWithFilePath<T>> {
     return this.getConfigFrom(this.searchPath, filePaths, options);
   }
@@ -283,7 +361,9 @@ export default class PublicConfig implements IConfig {
       return this.#pkg;
     }
 
-    let pkgConfig = await this.getConfig<PackageJSON>(['package.json']);
+    let pkgConfig = await this.getConfig<PackageJSON>(['package.json'], {
+      readTracking: getFeatureFlag('granularTsConfigInvalidation'),
+    });
     if (!pkgConfig) {
       return null;
     }

package/src/requests/ConfigRequest.js

@@ -63,7 +63,7 @@ export type ConfigRequest = {
   invalidateOnFileChange: Set<ProjectPath>,
   invalidateOnConfigKeyChange: Array<{|
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
   |}>,
   invalidateOnFileCreate: Array<InternalFileCreateInvalidation>,
   invalidateOnEnvChange: Set<string>,
@@ -108,34 +108,58 @@ export async function loadPluginConfig<T: PluginWithLoadConfig>(
   }
 }
 
+/**
+ * Return value at a given key path within an object.
+ *
+ * @example
+ *     const obj = { a: { b: { c: 'd' } } };
+ *     getValueAtPath(obj, ['a', 'b', 'c']);        // 'd'
+ *     getValueAtPath(obj, ['a', 'b', 'd']);        // undefined
+ *     getValueAtPath(obj, ['a', 'b']);             // { c: 'd' }
+ *     getValueAtPath(obj, ['a', 'b', 'c', 'd']);   // undefined
+ */
+export function getValueAtPath(obj: Object, key: string[]): any {
+  let current = obj;
+  for (let part of key) {
+    if (current == null) {
+      return undefined;
+    }
+    current = current[part];
+  }
+  return current;
+}
+
 const configKeyCache = createBuildCache();
 
 export async function getConfigKeyContentHash(
   filePath: ProjectPath,
-  configKey: string,
+  configKey: string[],
   options: AtlaspackOptions,
 ): Async<string> {
-  let cacheKey = `${fromProjectPathRelative(filePath)}:${configKey}`;
+  let cacheKey = `${fromProjectPathRelative(filePath)}:${JSON.stringify(
+    configKey,
+  )}`;
   let cachedValue = configKeyCache.get(cacheKey);
 
   if (cachedValue) {
     return cachedValue;
   }
 
-  let conf = await readConfig(
+  const conf = await readConfig(
     options.inputFS,
     fromProjectPath(options.projectRoot, filePath),
   );
 
-  if (conf == null || conf.config[configKey] == null) {
+  const value = getValueAtPath(conf?.config, configKey);
+  if (conf == null || value == null) {
     // This can occur when a config key has been removed entirely during `respondToFSEvents`
     return '';
   }
 
-  let contentHash =
-    typeof conf.config[configKey] === 'object'
-      ? hashObject(conf.config[configKey])
-      : hashString(JSON.stringify(conf.config[configKey]));
+  const contentHash =
+    typeof value === 'object'
+      ? hashObject(value)
+      : hashString(JSON.stringify(value));
 
   configKeyCache.set(cacheKey, contentHash);
 

package/src/types.js

@@ -499,7 +499,7 @@ export type Config = {|
   invalidateOnFileChange: Set<ProjectPath>,
   invalidateOnConfigKeyChange: Array<{|
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
   |}>,
   invalidateOnFileCreate: Array<InternalFileCreateInvalidation>,
   invalidateOnEnvChange: Set<string>,

package/test/public/Config.test.js

@@ -0,0 +1,108 @@
+// @flow strict-local
+
+import sinon from 'sinon';
+import {makeConfigProxy} from '../../src/public/Config';
+import assert from 'assert';
+
+describe('makeConfigProxy', () => {
+  it('tracks reads to nested fields', () => {
+    const onRead = sinon.spy();
+    const target = {a: {b: {c: 'd'}}};
+    const config = makeConfigProxy(onRead, target);
+    config.a.b.c;
+    assert.ok(onRead.calledWith(['a', 'b', 'c']));
+    assert.ok(onRead.calledOnce);
+  });
+
+  it('works for reading package.json dependencies', () => {
+    const packageJson = {
+      dependencies: {
+        react: '18.2.0',
+      },
+    };
+
+    const onRead = sinon.spy();
+    const config = makeConfigProxy(onRead, packageJson);
+    assert.equal(config.dependencies.react, '18.2.0');
+    // $FlowFixMe
+    assert.equal(config.dependencies.preact, undefined);
+    assert.ok(onRead.calledWith(['dependencies', 'react']));
+    assert.ok(onRead.calledWith(['dependencies', 'preact']));
+    assert.equal(onRead.callCount, 2);
+  });
+
+  it('will track reads for any missing or null keys', () => {
+    const packageJson = {
+      dependencies: {
+        react: '18.2.0',
+      },
+    };
+
+    const onRead = sinon.spy();
+    const config = makeConfigProxy(onRead, packageJson);
+
+    // $FlowFixMe
+    assert.equal(config.alias?.react, undefined);
+    assert.ok(onRead.calledWith(['alias']));
+    assert.equal(onRead.callCount, 1);
+  });
+
+  it('iterating over keys works normally and will register a read for the key being enumerated', () => {
+    const packageJson = {
+      nested: {
+        dependencies: {
+          react: '18.2.0',
+          'react-dom': '18.2.0',
+          'react-router': '6.14.2',
+        },
+      },
+    };
+
+    const onRead = sinon.spy();
+    const config = makeConfigProxy(onRead, packageJson);
+    assert.equal(Object.keys(config.nested.dependencies).length, 3);
+
+    assert.ok(onRead.calledWith(['nested', 'dependencies']));
+  });
+
+  it('if a key has an array value we will track a read for that key', () => {
+    const packageJson = {
+      scripts: ['build', 'test'],
+    };
+
+    const onRead = sinon.spy();
+    const config = makeConfigProxy(onRead, packageJson);
+    assert.equal(config.scripts[0], 'build');
+    assert.equal(onRead.callCount, 1);
+    assert.ok(onRead.calledWith(['scripts']));
+  });
+
+  it('if a key array value is iterated over we will track a read for that key', () => {
+    const packageJson = {
+      scripts: ['build', 'test'],
+    };
+
+    const onRead = sinon.spy();
+    const config = makeConfigProxy(onRead, packageJson);
+    let scriptCount = 0;
+    // eslint-disable-next-line no-unused-vars
+    for (const _script of config.scripts) {
+      scriptCount += 1;
+    }
+    assert.equal(scriptCount, 2);
+    assert.ok(onRead.calledWith(['scripts']));
+    assert.equal(onRead.callCount, 1);
+  });
+
+  it('if a key array value length is verified we will track a read for that key', () => {
+    const packageJson = {
+      scripts: ['build', 'test'],
+    };
+
+    const onRead = sinon.spy();
+    const config = makeConfigProxy(onRead, packageJson);
+    assert.equal(config.scripts.length, 2);
+    assert.ok(onRead.calledWith(['scripts']));
+    assert.equal(onRead.callCount, 1);
+  });
+});

package/test/requests/ConfigRequest.test.js

@@ -12,7 +12,10 @@ import type {
   ConfigRequestResult,
 } from '../../src/requests/ConfigRequest';
 import type {RunAPI} from '../../src/RequestTracker';
-import {runConfigRequest} from '../../src/requests/ConfigRequest';
+import {
+  getValueAtPath,
+  runConfigRequest,
+} from '../../src/requests/ConfigRequest';
 import {toProjectPath} from '../../src/projectPath';
 
 // $FlowFixMe unclear-type forgive me
@@ -228,7 +231,7 @@ describe('ConfigRequest tests', () => {
       ...baseRequest,
       invalidateOnConfigKeyChange: [
         {
-          configKey: 'key1',
+          configKey: ['key1'],
           filePath: toProjectPath(projectRoot, 'config.json'),
         },
       ],
@@ -244,8 +247,189 @@ describe('ConfigRequest tests', () => {
     const call = mockCast(mockRunApi.invalidateOnConfigKeyChange).getCall(0);
     assert.deepEqual(
       call.args,
-      ['config.json', 'key1', hashString('"value1"')],
+      ['config.json', ['key1'], hashString('"value1"')],
       'Invalidate was called for key1',
     );
   });
 });
+
+describe('getValueAtPath', () => {
+  it('can get a key from an object', () => {
+    const obj = {a: {b: {c: 'd'}}};
+    assert.equal(getValueAtPath(obj, ['a', 'b', 'c']), 'd');
+  });
+
+  it('returns the original object when key array is empty', () => {
+    const obj = {a: 1, b: 2};
+    assert.deepEqual(getValueAtPath(obj, []), obj);
+  });
+
+  it('can access single-level properties', () => {
+    const obj = {name: 'test', age: 25};
+    assert.equal(getValueAtPath(obj, ['name']), 'test');
+    assert.equal(getValueAtPath(obj, ['age']), 25);
+  });
+
+  it('returns undefined for non-existent keys', () => {
+    const obj = {a: {b: 'value'}};
+    assert.equal(getValueAtPath(obj, ['nonexistent']), undefined);
+    assert.equal(getValueAtPath(obj, ['a', 'nonexistent']), undefined);
+    assert.equal(getValueAtPath(obj, ['a', 'b', 'nonexistent']), undefined);
+  });
+
+  it('handles null and undefined values in the path', () => {
+    const obj = {a: null, b: {c: undefined}};
+    assert.equal(getValueAtPath(obj, ['a']), null);
+    assert.equal(getValueAtPath(obj, ['b', 'c']), undefined);
+  });
+
+  it('does not throw when trying to access property of null', () => {
+    const obj = {a: null};
+    assert.equal(getValueAtPath(obj, ['a', 'b']), undefined);
+  });
+
+  it('does not throw when trying to access property of undefined', () => {
+    const obj = {a: undefined};
+    assert.equal(getValueAtPath(obj, ['a', 'b']), undefined);
+  });
+
+  it('can access nested arrays and objects', () => {
+    const obj = {
+      data: [
+        {name: 'item1', props: {color: 'red'}},
+        {name: 'item2', props: {color: 'blue'}},
+      ],
+    };
+    assert.equal(getValueAtPath(obj, ['data', '0', 'name']), 'item1');
+    assert.equal(getValueAtPath(obj, ['data', '1', 'props', 'color']), 'blue');
+  });
+
+  it('handles numeric keys as strings', () => {
+    const obj = {'0': 'first', '1': {nested: 'value'}};
+    assert.equal(getValueAtPath(obj, ['0']), 'first');
+    assert.equal(getValueAtPath(obj, ['1', 'nested']), 'value');
+  });
+
+  it('handles keys with special characters', () => {
+    const obj = {
+      'key-with-dashes': 'value1',
+      'key.with.dots': {
+        'nested-key': 'value2',
+      },
+      'key with spaces': 'value3',
+      '@special$chars#': 'value4',
+    };
+    assert.equal(getValueAtPath(obj, ['key-with-dashes']), 'value1');
+    assert.equal(
+      getValueAtPath(obj, ['key.with.dots', 'nested-key']),
+      'value2',
+    );
+    assert.equal(getValueAtPath(obj, ['key with spaces']), 'value3');
+    assert.equal(getValueAtPath(obj, ['@special$chars#']), 'value4');
+  });
+
+  it('handles falsy values correctly', () => {
+    const obj = {
+      zero: 0,
+      false: false,
+      emptyString: '',
+      nullValue: null,
+      undefinedValue: undefined,
+      nested: {
+        zero: 0,
+        false: false,
+      },
+    };
+    assert.equal(getValueAtPath(obj, ['zero']), 0);
+    assert.equal(getValueAtPath(obj, ['false']), false);
+    assert.equal(getValueAtPath(obj, ['emptyString']), '');
+    assert.equal(getValueAtPath(obj, ['nullValue']), null);
+    assert.equal(getValueAtPath(obj, ['undefinedValue']), undefined);
+    assert.equal(getValueAtPath(obj, ['nested', 'zero']), 0);
+    assert.equal(getValueAtPath(obj, ['nested', 'false']), false);
+  });
+
+  it('handles deep nesting', () => {
+    const obj = {
+      level1: {
+        level2: {
+          level3: {
+            level4: {
+              level5: {
+                deepValue: 'found',
+              },
+            },
+          },
+        },
+      },
+    };
+    assert.equal(
+      getValueAtPath(obj, [
+        'level1',
+        'level2',
+        'level3',
+        'level4',
+        'level5',
+        'deepValue',
+      ]),
+      'found',
+    );
+  });
+
+  it('handles Date objects', () => {
+    const date = new Date('2023-01-01');
+    const obj = {
+      timestamp: date,
+      nested: {
+        date: date,
+      },
+    };
+    assert.equal(getValueAtPath(obj, ['timestamp']), date);
+    assert.equal(getValueAtPath(obj, ['nested', 'date']), date);
+  });
+
+  it('handles complex nested structures with mixed types', () => {
+    const obj = {
+      users: [
+        {
+          id: 1,
+          profile: {
+            settings: {
+              theme: 'dark',
+              notifications: true,
+            },
+          },
+        },
+        {
+          id: 2,
+          profile: {
+            settings: {
+              theme: 'light',
+              notifications: false,
+            },
+          },
+        },
+      ],
+      config: {
+        version: '1.0.0',
+        features: ['feature1', 'feature2'],
+      },
+    };
+
+    assert.equal(
+      getValueAtPath(obj, ['users', '0', 'profile', 'settings', 'theme']),
+      'dark',
+    );
+    assert.equal(
+      getValueAtPath(obj, [
+        'users',
+        '1',
+        'profile',
+        'settings',
+        'notifications',
+      ]),
+      false,
+    );
+    assert.equal(getValueAtPath(obj, ['config', 'features', '0']), 'feature1');
+  });
+});