@atlaspack/core 2.17.3 → 2.18.0

package/src/requests/TargetRequest.js

@@ -49,6 +49,7 @@ import {BROWSER_ENVS} from '../public/Environment';
 import {optionsProxy, toInternalSourceLocation} from '../utils';
 import {fromProjectPath, toProjectPath, joinProjectPath} from '../projectPath';
 import {requestTypes} from '../RequestTracker';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 type RunOpts<TResult> = {|
   input: Entry,
@@ -345,7 +346,7 @@ export class TargetResolver {
             },
           });
         }
-        if (!BROWSER_ENVS.has(targets[0].env.context)) {
+        if (!BROWSER_ENVS.has(fromEnvironmentId(targets[0].env).context)) {
           throw new ThrowableDiagnostic({
             diagnostic: {
               message: `Only browser targets are supported in serve mode`,
@@ -1491,21 +1492,22 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
 
     // Resolve relevant engines for context.
     let engines;
-    switch (target.env.context) {
+    const env = fromEnvironmentId(target.env);
+    switch (env.context) {
       case 'browser':
       case 'web-worker':
       case 'service-worker':
       case 'worklet': {
-        let browsers = target.env.engines.browsers;
+        let browsers = env.engines.browsers;
         engines = Array.isArray(browsers) ? browsers.join(', ') : browsers;
         break;
       }
       case 'node':
-        engines = target.env.engines.node;
+        engines = env.engines.node;
         break;
       case 'electron-main':
       case 'electron-renderer':
-        engines = target.env.engines.electron;
+        engines = env.engines.electron;
         break;
     }
 
@@ -1547,9 +1549,7 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
       }
 
       if (keyInfo.inferred) {
-        highlight.inferred.push(
-          md`${key} to be ${JSON.stringify(target.env[key])}`,
-        );
+        highlight.inferred.push(md`${key} to be ${JSON.stringify(env[key])}`);
       }
     }
 
@@ -1578,22 +1578,20 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
 
     // Format includeNodeModules to be human readable.
     let includeNodeModules;
-    if (typeof target.env.includeNodeModules === 'boolean') {
-      includeNodeModules = String(target.env.includeNodeModules);
-    } else if (Array.isArray(target.env.includeNodeModules)) {
+    if (typeof env.includeNodeModules === 'boolean') {
+      includeNodeModules = String(env.includeNodeModules);
+    } else if (Array.isArray(env.includeNodeModules)) {
       includeNodeModules =
         'only ' +
-        listFormat.format(
-          target.env.includeNodeModules.map((m) => JSON.stringify(m)),
-        );
+        listFormat.format(env.includeNodeModules.map((m) => JSON.stringify(m)));
     } else if (
-      target.env.includeNodeModules &&
-      typeof target.env.includeNodeModules === 'object'
+      env.includeNodeModules &&
+      typeof env.includeNodeModules === 'object'
     ) {
       includeNodeModules =
         'all except ' +
         listFormat.format(
-          Object.entries(target.env.includeNodeModules)
+          Object.entries(env.includeNodeModules)
             .filter(([, v]) => v === false)
             .map(([k]) => JSON.stringify(k)),
         );
@@ -1609,18 +1607,14 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
                  fromProjectPath(options.projectRoot, input.filePath),
                )}
               **Output**: ${path.relative(process.cwd(), output)}
-              **Format**: ${target.env.outputFormat} ${format(
-        info.outputFormat,
-      )}
-             **Context**: ${target.env.context} ${format(info.context)}
+              **Format**: ${env.outputFormat} ${format(info.outputFormat)}
+             **Context**: ${env.context} ${format(info.context)}
              **Engines**: ${engines || ''} ${format(info.engines)}
-        **Library Mode**: ${String(target.env.isLibrary)} ${format(
-        info.isLibrary,
-      )}
+        **Library Mode**: ${String(env.isLibrary)} ${format(info.isLibrary)}
 **Include Node Modules**: ${includeNodeModules} ${format(
         info.includeNodeModules,
       )}
-            **Optimize**: ${String(target.env.shouldOptimize)} ${format(
+            **Optimize**: ${String(env.shouldOptimize)} ${format(
         info.shouldOptimize,
       )}`,
       codeFrames: target.loc

package/src/requests/WriteBundleRequest.js

@@ -40,6 +40,8 @@ import {AtlaspackConfig} from '../AtlaspackConfig';
 import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
 import {PluginTracer, tracer} from '@atlaspack/profiler';
 import {requestTypes} from '../RequestTracker';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 const HASH_REF_PREFIX_LEN = HASH_REF_PREFIX.length;
 const BOUNDARY_LENGTH = HASH_REF_PREFIX.length + 32 - 1;
@@ -110,7 +112,9 @@ async function run({input, options, api}) {
   let cacheKeys = info.cacheKeys;
   let mapKey = cacheKeys.map;
   let fullPath = fromProjectPath(options.projectRoot, filePath);
-  if (mapKey && bundle.env.sourceMap && !bundle.env.sourceMap.inline) {
+  const env = fromEnvironmentId(bundle.env);
+
+  if (mapKey && env.sourceMap && !env.sourceMap.inline) {
     api.invalidateOnFileDelete(
       toProjectPath(options.projectRoot, fullPath + '.map'),
     );
@@ -167,14 +171,15 @@ async function run({input, options, api}) {
     api,
   );
 
-  if (
-    mapKey &&
-    bundle.env.sourceMap &&
-    !bundle.env.sourceMap.inline &&
-    (await options.cache.has(mapKey))
-  ) {
+  const hasSourceMap = getFeatureFlag('cachePerformanceImprovements')
+    ? await options.cache.hasLargeBlob(mapKey)
+    : await options.cache.has(mapKey);
+  if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
+    const mapEntry = getFeatureFlag('cachePerformanceImprovements')
+      ? await options.cache.getLargeBlob(mapKey)
+      : await options.cache.getBlob(mapKey);
     await writeFiles(
-      blobToStream(await options.cache.getBlob(mapKey)),
+      blobToStream(mapEntry),
       info,
       hashRefToNameHash,
       options,
@@ -189,6 +194,7 @@ async function run({input, options, api}) {
 
   let res = {
     filePath,
+    bundleId: bundle.id,
     type: info.type,
     stats: {
       size,

package/src/requests/WriteBundlesRequest.js

@@ -84,6 +84,7 @@ async function run({input, api, farm, options}) {
         ).replace(bundle.hashReference, hash);
         res.set(bundle.id, {
           filePath: joinProjectPath(bundle.target.distDir, name),
+          bundleId: bundle.id,
           type: bundle.type, // FIXME: this is wrong if the packager changes the type...
           stats: {
             time: 0,

package/src/resolveOptions.js

@@ -153,8 +153,10 @@ export default async function resolveOptions(
 
     const needsRustLmdbCache = getFeatureFlag('atlaspackV3');
 
-    if (!needsRustLmdbCache && !(outputFS instanceof NodeFS)) {
-      return new FSCache(outputFS, cacheDir);
+    if (!getFeatureFlag('cachePerformanceImprovements')) {
+      if (!needsRustLmdbCache && !(outputFS instanceof NodeFS)) {
+        return new FSCache(outputFS, cacheDir);
+      }
     }
 
     return new LMDBLiteCache(cacheDir);

package/src/types.js

@@ -34,6 +34,7 @@ import type {ProjectPath} from './projectPath';
 import type {Event} from '@parcel/watcher';
 import type {FeatureFlags} from '@atlaspack/feature-flags';
 import type {BackendType} from '@parcel/watcher';
+import type {EnvironmentRef} from './EnvironmentManager';
 
 export type AtlaspackPluginNode = {|
   packageName: PackageName,
@@ -97,7 +98,7 @@ export type InternalSourceLocation = {|
 export type Target = {|
   distEntry?: ?FilePath,
   distDir: ProjectPath,
-  env: Environment,
+  env: EnvironmentRef,
   name: string,
   publicUrl: string,
   loc?: ?InternalSourceLocation,
@@ -139,7 +140,7 @@ export type Dependency = {|
   isEntry: boolean,
   isOptional: boolean,
   loc: ?InternalSourceLocation,
-  env: Environment,
+  env: EnvironmentRef,
   packageConditions?: number,
   customPackageConditions?: Array<string>,
   meta: Meta,
@@ -180,7 +181,7 @@ export type Asset = {|
   bundleBehavior: ?$Values<typeof BundleBehavior>,
   isBundleSplittable: boolean,
   isSource: boolean,
-  env: Environment,
+  env: EnvironmentRef,
   meta: Meta,
   stats: Stats,
   contentKey: ?string,
@@ -388,7 +389,7 @@ export type RootNode = {|id: ContentKey, +type: 'root', value: string | null|};
 export type AssetRequestInput = {|
   name?: string, // AssetGraph name, needed so that different graphs can isolated requests since the results are not stored
   filePath: ProjectPath,
-  env: Environment,
+  env: EnvironmentRef,
   isSource?: boolean,
   canDefer?: boolean,
   sideEffects?: boolean,
@@ -492,13 +493,13 @@ export type Config = {|
   id: string,
   isSource: boolean,
   searchPath: ProjectPath,
-  env: Environment,
+  env: EnvironmentRef,
   cacheKey: ?string,
   result: ConfigResult,
   invalidateOnFileChange: Set<ProjectPath>,
   invalidateOnConfigKeyChange: Array<{|
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
   |}>,
   invalidateOnFileCreate: Array<InternalFileCreateInvalidation>,
   invalidateOnEnvChange: Set<string>,
@@ -539,7 +540,7 @@ export type Bundle = {|
   publicId: ?string,
   hashReference: string,
   type: string,
-  env: Environment,
+  env: EnvironmentRef,
   entryAssetIds: Array<ContentKey>,
   mainEntryId: ?ContentKey,
   needsStableName: ?boolean,
@@ -573,6 +574,7 @@ export type BundleGroupNode = {|
 
 export type PackagedBundleInfo = {|
   filePath: ProjectPath,
+  bundleId: ContentKey,
   type: string,
   stats: Stats,
 |};

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,
     );