@atlaspack/core 2.16.2-dev.55 → 2.16.2-dev.72

package/test/Environment.test.js

@@ -5,10 +5,11 @@ import assert from 'assert';
 import expect from 'expect';
 import {createEnvironment} from '../src/Environment';
 import {initializeMonitoring} from '../../rust';
+import {fromEnvironmentId} from '../src/EnvironmentManager';
 
 describe('Environment', () => {
   it('assigns a default environment with nothing passed', () => {
-    assert.deepEqual(createEnvironment(), {
+    assert.deepEqual(fromEnvironmentId(createEnvironment()), {
       id: 'd821e85f6b50315e',
       context: 'browser',
       engines: {
@@ -27,27 +28,32 @@ describe('Environment', () => {
   });
 
   it('assigns a node context if a node engine is given', () => {
-    assert.deepEqual(createEnvironment({engines: {node: '>= 10.0.0'}}), {
-      id: '2320af923a717577',
-      context: 'node',
-      engines: {
-        node: '>= 10.0.0',
+    assert.deepEqual(
+      fromEnvironmentId(createEnvironment({engines: {node: '>= 10.0.0'}})),
+      {
+        id: '2320af923a717577',
+        context: 'node',
+        engines: {
+          node: '>= 10.0.0',
+        },
+        includeNodeModules: false,
+        outputFormat: 'commonjs',
+        isLibrary: false,
+        shouldOptimize: false,
+        shouldScopeHoist: false,
+        sourceMap: undefined,
+        loc: undefined,
+        sourceType: 'module',
+        unstableSingleFileOutput: false,
       },
-      includeNodeModules: false,
-      outputFormat: 'commonjs',
-      isLibrary: false,
-      shouldOptimize: false,
-      shouldScopeHoist: false,
-      sourceMap: undefined,
-      loc: undefined,
-      sourceType: 'module',
-      unstableSingleFileOutput: false,
-    });
+    );
   });
 
   it('assigns a browser context if browser engines are given', () => {
     assert.deepEqual(
-      createEnvironment({engines: {browsers: ['last 1 version']}}),
+      fromEnvironmentId(
+        createEnvironment({engines: {browsers: ['last 1 version']}}),
+      ),
       {
         id: '75603271034eff15',
         context: 'browser',
@@ -68,7 +74,7 @@ describe('Environment', () => {
   });
 
   it('assigns default engines for node', () => {
-    assert.deepEqual(createEnvironment({context: 'node'}), {
+    assert.deepEqual(fromEnvironmentId(createEnvironment({context: 'node'})), {
       id: 'e45cc12216f7857d',
       context: 'node',
       engines: {
@@ -87,22 +93,25 @@ describe('Environment', () => {
   });
 
   it('assigns default engines for browsers', () => {
-    assert.deepEqual(createEnvironment({context: 'browser'}), {
-      id: 'd821e85f6b50315e',
-      context: 'browser',
-      engines: {
-        browsers: ['> 0.25%'],
+    assert.deepEqual(
+      fromEnvironmentId(createEnvironment({context: 'browser'})),
+      {
+        id: 'd821e85f6b50315e',
+        context: 'browser',
+        engines: {
+          browsers: ['> 0.25%'],
+        },
+        includeNodeModules: true,
+        outputFormat: 'global',
+        isLibrary: false,
+        shouldOptimize: false,
+        shouldScopeHoist: false,
+        sourceMap: undefined,
+        loc: undefined,
+        sourceType: 'module',
+        unstableSingleFileOutput: false,
       },
-      includeNodeModules: true,
-      outputFormat: 'global',
-      isLibrary: false,
-      shouldOptimize: false,
-      shouldScopeHoist: false,
-      sourceMap: undefined,
-      loc: undefined,
-      sourceType: 'module',
-      unstableSingleFileOutput: false,
-    });
+    );
   });
 });
 
@@ -114,6 +123,6 @@ describe('createEnvironment', function () {
       /* ignore */
     }
     const environment = createEnvironment({});
-    expect(environment.id).toEqual('d821e85f6b50315e');
+    expect(fromEnvironmentId(environment).id).toEqual('d821e85f6b50315e');
   });
 });

package/test/EnvironmentManager.test.js

@@ -0,0 +1,192 @@
+// @flow strict-local
+
+import assert from 'assert';
+import nullthrows from 'nullthrows';
+import sinon from 'sinon';
+import {ATLASPACK_VERSION} from '../src/constants';
+import {DEFAULT_FEATURE_FLAGS, setFeatureFlags} from '@atlaspack/feature-flags';
+import {setAllEnvironments, getAllEnvironments} from '@atlaspack/rust';
+import {
+  loadEnvironmentsFromCache,
+  writeEnvironmentsToCache,
+} from '../src/EnvironmentManager';
+import {DEFAULT_OPTIONS} from './test-utils';
+import {LMDBLiteCache} from '@atlaspack/cache';
+
+const options = {
+  ...DEFAULT_OPTIONS,
+  cache: new LMDBLiteCache(DEFAULT_OPTIONS.cacheDir),
+};
+
+describe('EnvironmentManager', () => {
+  const env1 = {
+    id: 'd821e85f6b50315e',
+    context: 'browser',
+    engines: {browsers: ['> 0.25%']},
+    includeNodeModules: true,
+    outputFormat: 'global',
+    isLibrary: false,
+    shouldOptimize: false,
+    shouldScopeHoist: false,
+    loc: undefined,
+    sourceMap: undefined,
+    sourceType: 'module',
+    unstableSingleFileOutput: false,
+  };
+  const env2 = {
+    id: 'de92f48baa8448d2',
+    context: 'node',
+    engines: {
+      browsers: [],
+      node: '>= 8',
+    },
+    includeNodeModules: false,
+    outputFormat: 'commonjs',
+    isLibrary: true,
+    shouldOptimize: true,
+    shouldScopeHoist: true,
+    loc: null,
+    sourceMap: null,
+    sourceType: 'module',
+    unstableSingleFileOutput: false,
+  };
+
+  beforeEach(async () => {
+    await options.cache.ensure();
+
+    for (const key of options.cache.keys()) {
+      await options.cache.getNativeRef().delete(key);
+    }
+    setAllEnvironments([]);
+
+    setFeatureFlags({
+      ...DEFAULT_FEATURE_FLAGS,
+      environmentDeduplication: true,
+    });
+  });
+
+  it('should store environments by ID in the cache', async () => {
+    setAllEnvironments([env1]);
+    await writeEnvironmentsToCache(options.cache);
+
+    const cachedEnv1 = await options.cache.get(
+      `Environment/${ATLASPACK_VERSION}/${env1.id}`,
+    );
+    assert.deepEqual(cachedEnv1, env1, 'Environment 1 should be cached');
+  });
+
+  it('should list all environment IDs in the environment manager', async () => {
+    const environmentIds = [env1.id, env2.id];
+    setAllEnvironments([env1, env2]);
+    await writeEnvironmentsToCache(options.cache);
+
+    const cachedEnvIds = await options.cache.get(
+      `EnvironmentManager/${ATLASPACK_VERSION}`,
+    );
+    const cachedIdsArray = nullthrows(cachedEnvIds);
+    assert.equal(
+      cachedIdsArray.length,
+      environmentIds.length,
+      'Should have same number of IDs',
+    );
+    assert(
+      environmentIds.every((id) => cachedIdsArray.includes(id)),
+      'All environment IDs should be present in cache',
+    );
+  });
+
+  it('should write all environments to cache using writeEnvironmentsToCache', async () => {
+    setAllEnvironments([env1, env2]);
+    await writeEnvironmentsToCache(options.cache);
+
+    // Verify each environment was stored individually
+    const cachedEnv1 = await options.cache.get(
+      `Environment/${ATLASPACK_VERSION}/${env1.id}`,
+    );
+    const cachedEnv2 = await options.cache.get(
+      `Environment/${ATLASPACK_VERSION}/${env2.id}`,
+    );
+    assert.deepEqual(cachedEnv1, env1, 'Environment 1 should be cached');
+    assert.deepEqual(cachedEnv2, env2, 'Environment 2 should be cached');
+
+    // Verify environment IDs were stored in manager
+    const cachedEnvIds = await options.cache.get(
+      `EnvironmentManager/${ATLASPACK_VERSION}`,
+    );
+    const cachedIdsArray = nullthrows(cachedEnvIds);
+    assert(
+      cachedIdsArray.length === 2 &&
+        [env1.id, env2.id].every((id) => cachedIdsArray.includes(id)),
+      'Environment IDs should be stored in manager',
+    );
+  });
+
+  it('should load environments from cache on loadRequestGraph on a subsequent build', async () => {
+    // Simulate cache written on a first build
+    setAllEnvironments([env1, env2]);
+    await writeEnvironmentsToCache(options.cache);
+
+    await loadEnvironmentsFromCache(options.cache);
+
+    const loadedEnvironments = getAllEnvironments();
+    assert.equal(
+      loadedEnvironments.length,
+      2,
+      'Should load 2 environments from cache',
+    );
+
+    const env1Loaded = loadedEnvironments.find((e) => e.id === env1.id);
+    const env2Loaded = loadedEnvironments.find((e) => e.id === env2.id);
+
+    assert.deepEqual(
+      env1Loaded,
+      env1,
+      'First environment should match cached environment',
+    );
+    assert.deepEqual(
+      env2Loaded,
+      env2,
+      'Second environment should match cached environment',
+    );
+  });
+
+  it('should handle empty cache gracefully without calling setAllEnvironments', async () => {
+    const setAllEnvironmentsSpy = sinon.spy(setAllEnvironments);
+
+    await assert.doesNotReject(
+      loadEnvironmentsFromCache(options.cache),
+      'loadEnvironmentsFromCache should not throw when cache is empty',
+    );
+
+    assert.equal(
+      setAllEnvironmentsSpy.callCount,
+      0,
+      'setAllEnvironments should not be called when loading from empty cache',
+    );
+  });
+
+  it('should not load environments from a different version', async () => {
+    const setAllEnvironmentsSpy = sinon.spy(setAllEnvironments);
+    const differentVersion = '2.17.2'; // A different version than ATLASPACK_VERSION
+
+    // Store an environment with a different version
+    await options.cache.set(`Environment/${differentVersion}/${env1.id}`, env1);
+    await options.cache.set(`EnvironmentManager/${differentVersion}`, [
+      env1.id,
+    ]);
+
+    await loadEnvironmentsFromCache(options.cache);
+
+    assert.equal(
+      setAllEnvironmentsSpy.callCount,
+      0,
+      'setAllEnvironments should not be called when loading from different version',
+    );
+    const loadedEnvironments = getAllEnvironments();
+    assert.equal(
+      loadedEnvironments.length,
+      0,
+      'Should not load any environments from different version',
+    );
+  });
+});

package/test/PublicEnvironment.test.js

@@ -2,19 +2,22 @@
 
 import assert from 'assert';
 import {createEnvironment} from '../src/Environment';
+import {fromEnvironmentId} from '../src/EnvironmentManager';
 import PublicEnvironment from '../src/public/Environment';
 import {DEFAULT_OPTIONS} from './test-utils';
 
 describe('Public Environment', () => {
   it('has correct support data for ChromeAndroid', () => {
     let env = new PublicEnvironment(
-      createEnvironment({
-        context: 'browser',
-        engines: {
-          browsers: ['last 1 Chrome version', 'last 1 ChromeAndroid version'],
-        },
-        outputFormat: 'esmodule',
-      }),
+      fromEnvironmentId(
+        createEnvironment({
+          context: 'browser',
+          engines: {
+            browsers: ['last 1 Chrome version', 'last 1 ChromeAndroid version'],
+          },
+          outputFormat: 'esmodule',
+        }),
+      ),
       DEFAULT_OPTIONS,
     );
 

package/test/RequestTracker.test.js

@@ -16,10 +16,7 @@ import {DEFAULT_OPTIONS} from './test-utils';
 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 '../../../unified/src/feature-flags/index.js';
+import {DEFAULT_FEATURE_FLAGS, setFeatureFlags} from '../../feature-flags/src';
 import sinon from 'sinon';
 import type {AtlaspackOptions} from '../src/types';
 

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');
+  });
+});

package/test/test-utils.js

@@ -1,6 +1,6 @@
 // @flow strict-local
 
-import type {Environment, AtlaspackOptions, Target} from '../src/types';
+import type {AtlaspackOptions, Target} from '../src/types';
 
 import {DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
 import {inputFS, outputFS, cache, cacheDir} from '@atlaspack/test-utils';
@@ -8,6 +8,7 @@ import {relativePath} from '@atlaspack/utils';
 import {NodePackageManager} from '@atlaspack/package-manager';
 import {createEnvironment} from '../src/Environment';
 import {toProjectPath} from '../src/projectPath';
+import type {EnvironmentRef} from '../src/EnvironmentManager';
 
 export const DEFAULT_OPTIONS: AtlaspackOptions = {
   cacheDir,
@@ -51,7 +52,7 @@ export const DEFAULT_OPTIONS: AtlaspackOptions = {
   },
 };
 
-export const DEFAULT_ENV: Environment = createEnvironment({
+export const DEFAULT_ENV: EnvironmentRef = createEnvironment({
   context: 'browser',
   engines: {
     browsers: ['> 1%'],