@atlaspack/core 2.17.3 → 2.18.0

package/src/BundleGraph.js

@@ -24,7 +24,6 @@ import type {
   BundleNode,
   Dependency,
   DependencyNode,
-  Environment,
   InternalSourceLocation,
   Target,
   Condition,
@@ -49,6 +48,8 @@ import {ISOLATED_ENVS} from './public/Environment';
 import {fromProjectPath, fromProjectPathRelative} from './projectPath';
 import {HASH_REF_PREFIX} from './constants';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
+import {fromEnvironmentId} from './EnvironmentManager';
+import type {EnvironmentRef} from './EnvironmentManager';
 
 export const bundleGraphEdgeTypes = {
   // A lack of an edge type indicates to follow the edge while traversing
@@ -283,7 +284,7 @@ export default class BundleGraph {
       if (
         node.type === 'dependency' &&
         node.value.symbols != null &&
-        node.value.env.shouldScopeHoist &&
+        fromEnvironmentId(node.value.env).shouldScopeHoist &&
         // Disable in dev mode because this feature is at odds with safeToIncrementallyBundle
         isProduction
       ) {
@@ -555,11 +556,11 @@ export default class BundleGraph {
           +needsStableName?: ?boolean,
           +bundleBehavior?: ?IBundleBehavior,
           +shouldContentHash: boolean,
-          +env: Environment,
+          +env: EnvironmentRef,
         |}
       | {|
           +type: string,
-          +env: Environment,
+          +env: EnvironmentRef,
           +uniqueKey: string,
           +target: Target,
           +needsStableName?: ?boolean,
@@ -1359,7 +1360,8 @@ export default class BundleGraph {
 
         if (
           descendant.type !== bundle.type ||
-          descendant.env.context !== bundle.env.context
+          fromEnvironmentId(descendant.env).context !==
+            fromEnvironmentId(bundle.env).context
         ) {
           actions.skipChildren();
           return;
@@ -1400,7 +1402,7 @@ export default class BundleGraph {
     // If a bundle's environment is isolated, it can't access assets present
     // in any ancestor bundles. Don't consider any assets reachable.
     if (
-      ISOLATED_ENVS.has(bundle.env.context) ||
+      ISOLATED_ENVS.has(fromEnvironmentId(bundle.env).context) ||
       !bundle.isSplittable ||
       bundle.bundleBehavior === BundleBehavior.isolated ||
       bundle.bundleBehavior === BundleBehavior.inline
@@ -1454,7 +1456,8 @@ export default class BundleGraph {
               node.type === 'root' ||
               (node.type === 'bundle' &&
                 (node.value.id === bundle.id ||
-                  node.value.env.context !== bundle.env.context))
+                  fromEnvironmentId(node.value.env).context !==
+                    fromEnvironmentId(bundle.env).context))
             ) {
               isReachable = false;
               actions.stop();
@@ -2128,7 +2131,9 @@ export default class BundleGraph {
       hash.writeString(referencedBundle.id);
     }
 
-    hash.writeString(JSON.stringify(objectSortedEntriesDeep(bundle.env)));
+    hash.writeString(
+      JSON.stringify(objectSortedEntriesDeep(fromEnvironmentId(bundle.env))),
+    );
     return hash.finish();
   }
 

package/src/Dependency.js

@@ -8,7 +8,7 @@ import type {
   BundleBehavior as IBundleBehavior,
   SemverRange,
 } from '@atlaspack/types';
-import type {Dependency, Environment, Target} from './types';
+import type {Dependency, Target} from './types';
 import {createDependencyId as createDependencyIdRust} from '@atlaspack/rust';
 import {
   SpecifierType,
@@ -21,6 +21,8 @@ import {toInternalSourceLocation} from './utils';
 import {toProjectPath} from './projectPath';
 import assert from 'assert';
 import {identifierRegistry} from './IdentifierRegistry';
+import {fromEnvironmentId, toEnvironmentId} from './EnvironmentManager';
+import type {EnvironmentRef} from './EnvironmentManager';
 
 type DependencyOpts = {|
   id?: string,
@@ -34,7 +36,7 @@ type DependencyOpts = {|
   isEntry?: boolean,
   isOptional?: boolean,
   loc?: SourceLocation,
-  env: Environment,
+  env: EnvironmentRef,
   packageConditions?: Array<string>,
   meta?: Meta,
   resolveFrom?: FilePath,
@@ -60,7 +62,7 @@ export function createDependencyId({
 }: {|
   sourceAssetId?: string | void,
   specifier: DependencySpecifier,
-  env: Environment,
+  env: EnvironmentRef,
   target?: Target | void,
   pipeline?: ?string,
   specifierType: $Keys<typeof SpecifierType>,
@@ -73,8 +75,14 @@ export function createDependencyId({
   const params = {
     sourceAssetId,
     specifier,
-    environmentId: env.id,
-    target,
+    environmentId: toEnvironmentId(env),
+    target:
+      target != null
+        ? {
+            ...target,
+            env: fromEnvironmentId(target.env),
+          }
+        : null,
     pipeline,
     specifierType: SpecifierType[specifierType],
     bundleBehavior,

package/src/Environment.js

@@ -10,6 +10,8 @@ import {toInternalSourceLocation} from './utils';
 import PublicEnvironment from './public/Environment';
 import {environmentToInternalEnvironment} from './public/Environment';
 import {identifierRegistry} from './IdentifierRegistry';
+import {toEnvironmentRef} from './EnvironmentManager';
+import type {EnvironmentRef} from './EnvironmentManager';
 
 const DEFAULT_ENGINES = {
   browsers: ['> 0.25%'],
@@ -35,7 +37,7 @@ export function createEnvironment({
   loc,
 }: EnvironmentOpts = {
   /*::...null*/
-}): Environment {
+}): EnvironmentRef {
   if (context == null) {
     if (engines?.node) {
       context = 'node';
@@ -112,21 +114,22 @@ export function createEnvironment({
   };
 
   res.id = getEnvironmentHash(res);
-  return Object.freeze(res);
+
+  return toEnvironmentRef(Object.freeze(res));
 }
 
 export function mergeEnvironments(
   projectRoot: FilePath,
   a: Environment,
   b: ?(EnvironmentOptions | IEnvironment),
-): Environment {
+): EnvironmentRef {
   // If merging the same object, avoid copying.
   if (a === b || !b) {
-    return a;
+    return toEnvironmentRef(a);
   }
 
   if (b instanceof PublicEnvironment) {
-    return environmentToInternalEnvironment(b);
+    return toEnvironmentRef(environmentToInternalEnvironment(b));
   }
 
   // $FlowFixMe - ignore the `id` that is already on a

package/src/EnvironmentManager.js

@@ -0,0 +1,145 @@
+// @flow strict-local
+/*!
+ * At the moment we're doing this change for `CoreEnvironment`,
+ * but the same change must be made for `TypesEnvironment` in @atlaspack/types.
+ */
+import type {Environment as CoreEnvironment} from './types';
+import {type Cache} from '@atlaspack/cache';
+import {
+  addEnvironment,
+  getEnvironment,
+  getAllEnvironments,
+  setAllEnvironments,
+} from '@atlaspack/rust';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+import {instrument} from '@atlaspack/logger';
+import {ATLASPACK_VERSION} from './constants';
+
+const localEnvironmentCache = new Map<string, CoreEnvironment>();
+
+export opaque type EnvironmentId = string;
+/**
+ * When deduplication is cleaned-up this will always be a string.
+ */
+export type EnvironmentRef = EnvironmentId | CoreEnvironment;
+
+/**
+ * Convert environment to a ref.
+ * This is what we should be using to store environments.
+ */
+export function toEnvironmentRef(env: CoreEnvironment): EnvironmentRef {
+  if (!getFeatureFlag('environmentDeduplication')) {
+    return env;
+  }
+
+  const id = toEnvironmentId(env);
+  return id;
+}
+
+/**
+ * Convert environment to a string ID
+ */
+export function toEnvironmentId(
+  /**
+   * Redundant type during roll-out
+   */
+  env: CoreEnvironment | EnvironmentRef,
+): string {
+  if (!getFeatureFlag('environmentDeduplication')) {
+    return typeof env === 'string' ? env : env.id;
+  }
+
+  if (typeof env === 'string') {
+    return env;
+  }
+
+  addEnvironment(env);
+  return env.id;
+}
+
+export function fromEnvironmentId(id: EnvironmentRef): CoreEnvironment {
+  if (!getFeatureFlag('environmentDeduplication')) {
+    if (typeof id === 'string') {
+      throw new Error(
+        'This should never happen when environmentDeduplication feature-flag is off',
+      );
+    } else {
+      return id;
+    }
+  }
+
+  if (typeof id !== 'string') {
+    return id;
+  }
+
+  const localEnv = localEnvironmentCache.get(id);
+
+  if (localEnv) {
+    return localEnv;
+  }
+
+  const env = Object.freeze(getEnvironment(id));
+  localEnvironmentCache.set(id, env);
+  return env;
+}
+
+/**
+ * Writes all environments and their IDs to the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+export async function writeEnvironmentsToCache(cache: Cache): Promise<void> {
+  const environments = getAllEnvironments();
+  const environmentIds = new Set<string>();
+
+  // Store each environment individually
+  for (const env of environments) {
+    environmentIds.add(env.id);
+    const envKey = `Environment/${ATLASPACK_VERSION}/${env.id}`;
+
+    await instrument(
+      `RequestTracker::writeToCache::cache.put(${envKey})`,
+      async () => {
+        await cache.set(envKey, env);
+      },
+    );
+  }
+
+  // Store the list of environment IDs
+  await instrument(
+    `RequestTracker::writeToCache::cache.put(${`EnvironmentManager/${ATLASPACK_VERSION}`})`,
+    async () => {
+      await cache.set(
+        `EnvironmentManager/${ATLASPACK_VERSION}`,
+        Array.from(environmentIds),
+      );
+    },
+  );
+}
+
+/**
+ * Loads all environments and their IDs from the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+export async function loadEnvironmentsFromCache(cache: Cache): Promise<void> {
+  const cachedEnvIds = await cache.get(
+    `EnvironmentManager/${ATLASPACK_VERSION}`,
+  );
+
+  if (cachedEnvIds == null) {
+    return;
+  }
+
+  const environments = [];
+  for (const envId of cachedEnvIds) {
+    const envKey = `Environment/${ATLASPACK_VERSION}/${envId}`;
+    const cachedEnv = await cache.get(envKey);
+    if (cachedEnv != null) {
+      environments.push(cachedEnv);
+    }
+  }
+  if (environments.length > 0) {
+    setAllEnvironments(environments);
+  }
+}

package/src/InternalConfig.js

@@ -3,7 +3,6 @@
 import type {PackageName, ConfigResult} from '@atlaspack/types';
 import type {
   Config,
-  Environment,
   InternalFileCreateInvalidation,
   InternalDevDepOptions,
 } from './types';
@@ -13,17 +12,19 @@ import {fromProjectPathRelative} from './projectPath';
 import {createEnvironment} from './Environment';
 import {hashString} from '@atlaspack/rust';
 import {identifierRegistry} from './IdentifierRegistry';
+import type {EnvironmentRef} from './EnvironmentManager';
+import {toEnvironmentId} from './EnvironmentManager';
 
 type ConfigOpts = {|
   plugin: PackageName,
   searchPath: ProjectPath,
   isSource?: boolean,
-  env?: Environment,
+  env?: EnvironmentRef,
   result?: ConfigResult,
   invalidateOnFileChange?: Set<ProjectPath>,
   invalidateOnConfigKeyChange?: Array<{|
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
   |}>,
   invalidateOnFileCreate?: Array<InternalFileCreateInvalidation>,
   invalidateOnEnvChange?: Set<string>,
@@ -52,13 +53,13 @@ export function createConfig({
   const configId = hashString(
     plugin +
       fromProjectPathRelative(searchPath) +
-      environment.id +
+      toEnvironmentId(environment) +
       String(isSource),
   );
   identifierRegistry.addIdentifier('config_request', configId, {
     plugin,
     searchPath,
-    environmentId: environment.id,
+    environmentId: toEnvironmentId(environment),
     isSource,
   });
   return {

package/src/PackagerRunner.js

@@ -63,6 +63,8 @@ import {getInvalidationId, getInvalidationHash} from './assetUtils';
 import {optionsProxy} from './utils';
 import {invalidateDevDeps} from './requests/DevDepRequest';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
+import {fromEnvironmentId} from './EnvironmentManager';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 type Opts = {|
   config: AtlaspackConfig,
@@ -577,32 +579,32 @@ export default class PackagerRunner {
     );
     let inlineSources = false;
 
+    const bundleEnv = fromEnvironmentId(bundle.env);
     if (bundle.target) {
-      if (
-        bundle.env.sourceMap &&
-        bundle.env.sourceMap.sourceRoot !== undefined
-      ) {
-        sourceRoot = bundle.env.sourceMap.sourceRoot;
+      const bundleTargetEnv = fromEnvironmentId(bundle.target.env);
+
+      if (bundleEnv.sourceMap && bundleEnv.sourceMap.sourceRoot !== undefined) {
+        sourceRoot = bundleEnv.sourceMap.sourceRoot;
       } else if (
         this.options.serveOptions &&
-        bundle.target.env.context === 'browser'
+        bundleTargetEnv.context === 'browser'
       ) {
         sourceRoot = '/__parcel_source_root';
       }
 
       if (
-        bundle.env.sourceMap &&
-        bundle.env.sourceMap.inlineSources !== undefined
+        bundleEnv.sourceMap &&
+        bundleEnv.sourceMap.inlineSources !== undefined
       ) {
-        inlineSources = bundle.env.sourceMap.inlineSources;
-      } else if (bundle.target.env.context !== 'node') {
+        inlineSources = bundleEnv.sourceMap.inlineSources;
+      } else if (bundleTargetEnv.context !== 'node') {
         // inlining should only happen in production for browser targets by default
         inlineSources = this.options.mode === 'production';
       }
     }
 
     let mapFilename = fullPath + '.map';
-    let isInlineMap = bundle.env.sourceMap && bundle.env.sourceMap.inline;
+    let isInlineMap = bundleEnv.sourceMap && bundleEnv.sourceMap.inline;
 
     let stringified = await map.stringify({
       file: path.basename(mapFilename),
@@ -658,6 +660,21 @@ export default class PackagerRunner {
       this.options,
     );
 
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      const hash = hashString(
+        ATLASPACK_VERSION +
+          devDepHashes +
+          invalidationHash +
+          bundle.target.publicUrl +
+          bundleGraph.getHash(bundle) +
+          JSON.stringify(configResults) +
+          JSON.stringify(globalInfoResults) +
+          this.options.mode +
+          (this.options.shouldBuildLazily ? 'lazy' : 'eager'),
+      );
+      return path.join(bundle.displayName ?? bundle.name ?? bundle.id, hash);
+    }
+
     return hashString(
       ATLASPACK_VERSION +
         devDepHashes +
@@ -700,20 +717,27 @@ export default class PackagerRunner {
     let mapKey = PackagerRunner.getMapKey(cacheKey);
 
     let isLargeBlob = await this.options.cache.hasLargeBlob(contentKey);
-    let contentExists =
-      isLargeBlob || (await this.options.cache.has(contentKey));
+    let contentExists = getFeatureFlag('cachePerformanceImprovements')
+      ? isLargeBlob
+      : isLargeBlob || (await this.options.cache.has(contentKey));
     if (!contentExists) {
       return null;
     }
 
-    let mapExists = await this.options.cache.has(mapKey);
+    let mapExists = getFeatureFlag('cachePerformanceImprovements')
+      ? await this.options.cache.hasLargeBlob(mapKey)
+      : await this.options.cache.has(mapKey);
 
     return {
       contents: isLargeBlob
         ? this.options.cache.getStream(contentKey)
         : blobToStream(await this.options.cache.getBlob(contentKey)),
       map: mapExists
-        ? blobToStream(await this.options.cache.getBlob(mapKey))
+        ? blobToStream(
+            getFeatureFlag('cachePerformanceImprovements')
+              ? await this.options.cache.getLargeBlob(mapKey)
+              : await this.options.cache.getBlob(mapKey),
+          )
         : null,
     };
   }
@@ -727,11 +751,14 @@ export default class PackagerRunner {
     let size = 0;
     let hash;
     let hashReferences = [];
-    let isLargeBlob = false;
+    let isLargeBlob = getFeatureFlag('cachePerformanceImprovements');
 
     // TODO: don't replace hash references in binary files??
     if (contents instanceof Readable) {
-      isLargeBlob = true;
+      if (!getFeatureFlag('cachePerformanceImprovements')) {
+        isLargeBlob = true;
+      }
+
       let boundaryStr = '';
       let h = new Hash();
       await this.options.cache.setStream(
@@ -754,17 +781,32 @@ export default class PackagerRunner {
       size = buffer.byteLength;
       hash = hashBuffer(buffer);
       hashReferences = contents.match(HASH_REF_REGEX) ?? [];
-      await this.options.cache.setBlob(cacheKeys.content, buffer);
+
+      if (getFeatureFlag('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.content, buffer);
+      } else {
+        await this.options.cache.setBlob(cacheKeys.content, buffer);
+      }
     } else {
       size = contents.length;
       hash = hashBuffer(contents);
       hashReferences = contents.toString().match(HASH_REF_REGEX) ?? [];
-      await this.options.cache.setBlob(cacheKeys.content, contents);
+
+      if (getFeatureFlag('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.content, contents);
+      } else {
+        await this.options.cache.setBlob(cacheKeys.content, contents);
+      }
     }
 
     if (map != null) {
-      await this.options.cache.setBlob(cacheKeys.map, map);
+      if (getFeatureFlag('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.map, map);
+      } else {
+        await this.options.cache.setBlob(cacheKeys.map, map);
+      }
     }
+
     let info = {
       type,
       size,
@@ -773,19 +815,29 @@ export default class PackagerRunner {
       cacheKeys,
       isLargeBlob,
     };
+
     await this.options.cache.set(cacheKeys.info, info);
     return info;
   }
 
   static getContentKey(cacheKey: string): string {
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      return `PackagerRunner/${ATLASPACK_VERSION}/${cacheKey}/content`;
+    }
     return hashString(`${cacheKey}:content`);
   }
 
   static getMapKey(cacheKey: string): string {
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      return `PackagerRunner/${ATLASPACK_VERSION}/${cacheKey}/map`;
+    }
     return hashString(`${cacheKey}:map`);
   }
 
   static getInfoKey(cacheKey: string): string {
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      return `PackagerRunner/${ATLASPACK_VERSION}/${cacheKey}/info`;
+    }
     return hashString(`${cacheKey}:info`);
   }
 }