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

package/src/UncommittedAsset.js

@@ -30,7 +30,12 @@ import {ATLASPACK_VERSION} from './constants';
 import {createAsset, createAssetIdFromOptions} from './assetUtils';
 import {BundleBehaviorNames} from './types';
 import {invalidateOnFileCreateToInternal, createInvalidations} from './utils';
-import {type ProjectPath, fromProjectPath} from './projectPath';
+import {
+  type ProjectPath,
+  fromProjectPath,
+  fromProjectPathRelative,
+} from './projectPath';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 type UncommittedAssetOptions = {|
   value: Asset,
@@ -153,7 +158,9 @@ export default class UncommittedAsset {
       size = content.length;
     }
 
+    // Maybe we should just store this in a file instead of LMDB
     await this.options.cache.setBlob(contentKey, content);
+
     return {size, hash};
   }
 
@@ -214,6 +221,9 @@ export default class UncommittedAsset {
     this.clearAST();
   }
 
+  /**
+   * @deprecated This has been broken on any cache other than FSCache for a long time.
+   */
   setStream(stream: Readable) {
     this.content = stream;
     this.clearAST();
@@ -296,6 +306,11 @@ export default class UncommittedAsset {
   }
 
   getCacheKey(key: string): string {
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      const filePath = fromProjectPathRelative(this.value.filePath);
+      return `Asset/${ATLASPACK_VERSION}/${filePath}/${this.value.id}/${key}`;
+    }
+
     return hashString(ATLASPACK_VERSION + key + this.value.id);
   }
 

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

@@ -100,11 +100,15 @@ export class PluginConfig implements IPluginConfig {
     // eslint-disable-next-line no-unused-vars
     filePaths: Array<FilePath>,
     // eslint-disable-next-line no-unused-vars
-    options?: {|
-      packageKey?: string,
-      parse?: boolean,
-      exclude?: boolean,
-    |},
+    options?:
+      | {|
+          packageKey?: string,
+          parse?: boolean,
+          exclude?: boolean,
+        |}
+      | {|
+          configKey?: string,
+        |},
   ): Promise<?ConfigResultWithFilePath<T>> {
     return this.#inner.getConfigFrom(searchPath, filePaths, options);
   }

package/src/atlaspack-v3/worker/worker.js

@@ -141,6 +141,13 @@ export class AtlaspackWorker {
         };
       }
 
+      if (result.isExcluded) {
+        return {
+          invalidations: [],
+          resolution: {type: 'excluded'},
+        };
+      }
+
       return {
         invalidations: [],
         resolution: {

package/src/public/BundleGraph.js

@@ -31,6 +31,7 @@ import Dependency, {
 import {targetToInternalTarget} from './Target';
 import {fromInternalSourceLocation} from '../utils';
 import BundleGroup, {bundleGroupToInternalBundleGroup} from './BundleGroup';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 // Friendly access for other modules within this package that need access
 // to the internal bundle.
@@ -185,16 +186,6 @@ export default class BundleGraph<TBundle: IBundle>
     );
   }
 
-  getReferencedAssets(
-    bundle: IBundle,
-    cache: Map<Bundle, Set<string>>,
-  ): Set<string> {
-    return this.#graph.getReferencedAssets(
-      bundleToInternalBundle(bundle),
-      cache,
-    );
-  }
-
   hasParentBundleOfType(bundle: IBundle, type: string): boolean {
     return this.#graph.hasParentBundleOfType(
       bundleToInternalBundle(bundle),
@@ -499,11 +490,27 @@ export default class BundleGraph<TBundle: IBundle>
       for (let bundle of bundles) {
         const conditions = bundleConditions.get(bundle.id) ?? new Map();
 
-        conditions.set(cond.key, {
-          bundle,
-          ifTrueBundles,
-          ifFalseBundles,
-        });
+        const currentCondition = conditions.get(cond.key);
+
+        if (getFeatureFlag('conditionalBundlingReporterSameConditionFix')) {
+          conditions.set(cond.key, {
+            bundle,
+            ifTrueBundles: [
+              ...(currentCondition?.ifTrueBundles ?? []),
+              ...ifTrueBundles,
+            ],
+            ifFalseBundles: [
+              ...(currentCondition?.ifFalseBundles ?? []),
+              ...ifFalseBundles,
+            ],
+          });
+        } else {
+          conditions.set(cond.key, {
+            bundle,
+            ifTrueBundles,
+            ifFalseBundles,
+          });
+        }
 
         bundleConditions.set(bundle.id, conditions);
       }

package/src/public/Config.js

@@ -20,6 +20,7 @@ import {
 } from '@atlaspack/utils';
 import Environment from './Environment';
 import {fromProjectPath, toProjectPath} from '../projectPath';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 const internalConfigToConfig: DefaultWeakMap<
   AtlaspackOptions,
@@ -132,11 +133,21 @@ export default class PublicConfig implements IConfig {
   async getConfigFrom<T>(
     searchPath: FilePath,
     fileNames: Array<string>,
-    options: ?{|
-      packageKey?: string,
-      parse?: boolean,
-      exclude?: boolean,
-    |},
+    options:
+      | ?{|
+          /**
+           * @deprecated Use `configKey` instead.
+           */
+          packageKey?: string,
+          parse?: boolean,
+          exclude?: boolean,
+        |}
+      | ?{|
+          /**
+           * If specified, only invalidate when this config key changes.
+           */
+          configKey?: string,
+        |},
   ): Promise<?ConfigResultWithFilePath<T>> {
     let packageKey = options?.packageKey;
     if (packageKey != null) {
@@ -155,6 +166,29 @@ 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,
+          });
+
+          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
+      }
+    }
+
     if (fileNames.length === 0) {
       return null;
     }

package/src/requests/AssetGraphRequest.js

@@ -20,6 +20,7 @@ import logger from '@atlaspack/logger';
 
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {PromiseQueue, setEqual} from '@atlaspack/utils';
 import {hashString} from '@atlaspack/rust';
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
@@ -161,12 +162,21 @@ export class AssetGraphBuilder {
     this.shouldBuildLazily = shouldBuildLazily ?? false;
     this.lazyIncludes = lazyIncludes ?? [];
     this.lazyExcludes = lazyExcludes ?? [];
-    this.cacheKey =
-      hashString(
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      const key = hashString(
         `${ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${
           options.mode
         }${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
-      ) + '-AssetGraph';
+      );
+      this.cacheKey = `AssetGraph/${ATLASPACK_VERSION}/${options.mode}/${key}`;
+    } else {
+      this.cacheKey =
+        hashString(
+          `${ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${
+            options.mode
+          }${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
+        ) + '-AssetGraph';
+    }
 
     this.isSingleChangeRebuild =
       api

package/src/requests/BundleGraphRequest.js

@@ -20,6 +20,7 @@ import invariant from 'assert';
 import assert from 'assert';
 import nullthrows from 'nullthrows';
 import {PluginLogger} from '@atlaspack/logger';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
 import AssetGraph from '../AssetGraph';
 import BundleGraph from '../public/BundleGraph';
@@ -282,12 +283,21 @@ class BundlerRunner {
     this.pluginOptions = new PluginOptions(
       optionsProxy(this.options, api.invalidateOnOptionChange),
     );
-    this.cacheKey =
-      hashString(
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      const key = hashString(
         `${ATLASPACK_VERSION}:BundleGraph:${
           JSON.stringify(options.entries) ?? ''
         }${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
-      ) + '-BundleGraph';
+      );
+      this.cacheKey = `BundleGraph/${ATLASPACK_VERSION}/${options.mode}/${key}`;
+    } else {
+      this.cacheKey =
+        hashString(
+          `${ATLASPACK_VERSION}:BundleGraph:${
+            JSON.stringify(options.entries) ?? ''
+          }${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`,
+        ) + '-BundleGraph';
+    }
   }
 
   async loadConfigs() {

package/src/requests/WriteBundleRequest.js

@@ -40,6 +40,7 @@ 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';
 
 const HASH_REF_PREFIX_LEN = HASH_REF_PREFIX.length;
 const BOUNDARY_LENGTH = HASH_REF_PREFIX.length + 32 - 1;
@@ -167,14 +168,20 @@ async function run({input, options, api}) {
     api,
   );
 
+  const hasSourceMap = getFeatureFlag('cachePerformanceImprovements')
+    ? await options.cache.hasLargeBlob(mapKey)
+    : await options.cache.has(mapKey);
   if (
     mapKey &&
     bundle.env.sourceMap &&
     !bundle.env.sourceMap.inline &&
-    (await options.cache.has(mapKey))
+    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,

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/test/RequestTracker.test.js

@@ -5,19 +5,39 @@ import nullthrows from 'nullthrows';
 import RequestTracker, {
   type RunAPI,
   cleanUpOrphans,
+  runInvalidation,
+  getBiggestFSEventsInvalidations,
+  invalidateRequestGraphFSEvents,
 } from '../src/RequestTracker';
 import {Graph} from '@atlaspack/graph';
+import {LMDBLiteCache} from '@atlaspack/cache';
 import WorkerFarm from '@atlaspack/workers';
 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 '../../feature-flags/src';
-
-const options = DEFAULT_OPTIONS;
+import {
+  DEFAULT_FEATURE_FLAGS,
+  setFeatureFlags,
+} from '../../../unified/src/feature-flags/index.js';
+import sinon from 'sinon';
+import type {AtlaspackOptions} from '../src/types';
+
+const options = {
+  ...DEFAULT_OPTIONS,
+  cache: new LMDBLiteCache(DEFAULT_OPTIONS.cacheDir),
+};
 const farm = new WorkerFarm({workerPath: require.resolve('../src/worker')});
 
 describe('RequestTracker', () => {
+  beforeEach(async () => {
+    await options.cache.ensure();
+
+    for (const key of options.cache.keys()) {
+      await options.cache.getNativeRef().delete(key);
+    }
+  });
+
   it('should not run requests that have not been invalidated', async () => {
     let tracker = new RequestTracker({farm, options});
     await tracker.runRequest({
@@ -482,7 +502,7 @@ describe('RequestTracker', () => {
             input: null,
           });
           const requestId = tracker.graph.getNodeIdByContentKey('abc');
-          const invalidated = await tracker.respondToFSEvents(
+          const {didInvalidate: invalidated} = await tracker.respondToFSEvents(
             [
               {
                 type: 'update',
@@ -521,7 +541,7 @@ describe('RequestTracker', () => {
             input: null,
           });
           const requestId = tracker.graph.getNodeIdByContentKey('abc');
-          const invalidated = await tracker.respondToFSEvents(
+          const {didInvalidate: invalidated} = await tracker.respondToFSEvents(
             [
               {
                 type: 'create',
@@ -584,3 +604,98 @@ root --- node1 --- node2 ----------- orphan1 --- orphan2
     assert.equal(Array.from(graph.getAllEdges()).length, 3);
   });
 });
+
+describe('runInvalidation', () => {
+  it('calls an invalidationFn and tracks the number of invalidated nodes', async () => {
+    const mockRequestTracker = {
+      getInvalidNodeCount: sinon.stub(),
+    };
+
+    mockRequestTracker.getInvalidNodeCount.returns(10000);
+    const result = await runInvalidation(mockRequestTracker, {
+      key: 'fsEvents',
+      fn: () => {
+        mockRequestTracker.getInvalidNodeCount.returns(30000);
+        return {
+          biggestInvalidations: [{path: 'my-file', count: 10000}],
+        };
+      },
+    });
+
+    assert.equal(result.key, 'fsEvents');
+    assert.equal(result.count, 20000);
+    assert.deepEqual(result.detail, {
+      biggestInvalidations: [{path: 'my-file', count: 10000}],
+    });
+    assert(result.duration > 0, 'Duration was not reported');
+  });
+});
+
+describe('invalidateRequestGraphFSEvents', () => {
+  it('calls requestGraph.respondToFSEvents and returns the biggest invalidations', async () => {
+    const requestGraph = {
+      respondToFSEvents: sinon.stub(),
+    };
+
+    requestGraph.respondToFSEvents.returns({
+      invalidationsByPath: new Map([
+        ['file-1', 10],
+        ['file-2', 5000],
+        ['file-3', 8000],
+      ]),
+    });
+    // $FlowFixMe
+    const options: AtlaspackOptions = {
+      unstableFileInvalidations: undefined,
+    };
+
+    const result = await invalidateRequestGraphFSEvents(requestGraph, options, [
+      {
+        path: 'file-1',
+        type: 'create',
+      },
+      {
+        path: 'file-2',
+        type: 'update',
+      },
+      {
+        path: 'file-3',
+        type: 'delete',
+      },
+    ]);
+
+    assert.deepEqual(result.biggestInvalidations, [
+      {path: 'file-3', count: 8000},
+      {path: 'file-2', count: 5000},
+      {path: 'file-1', count: 10},
+    ]);
+    assert.equal(requestGraph.respondToFSEvents.callCount, 1);
+    assert.deepEqual(requestGraph.respondToFSEvents.args[0], [
+      [
+        {path: 'file-1', type: 'create'},
+        {path: 'file-2', type: 'update'},
+        {path: 'file-3', type: 'delete'},
+      ],
+      options,
+      10000,
+      true,
+    ]);
+  });
+});
+
+describe('getBiggestFSEventsInvalidations', () => {
+  it('returns the paths that invalidated the most nodes', () => {
+    const invalidationsByPath = new Map([
+      ['file-1', 10],
+      ['file-2', 5000],
+      ['file-3', 8000],
+      ['file-4', 1000],
+      ['file-5', 1000],
+    ]);
+
+    assert.deepEqual(getBiggestFSEventsInvalidations(invalidationsByPath, 2), [
+      {path: 'file-3', count: 8000},
+      {path: 'file-2', count: 5000},
+    ]);
+  });
+});

package/test/test-utils.js

@@ -3,18 +3,12 @@
 import type {Environment, AtlaspackOptions, Target} from '../src/types';
 
 import {DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
-import {FSCache} from '@atlaspack/cache';
-import tempy from 'tempy';
-import {inputFS, outputFS} from '@atlaspack/test-utils';
+import {inputFS, outputFS, cache, cacheDir} from '@atlaspack/test-utils';
 import {relativePath} from '@atlaspack/utils';
 import {NodePackageManager} from '@atlaspack/package-manager';
 import {createEnvironment} from '../src/Environment';
 import {toProjectPath} from '../src/projectPath';
 
-let cacheDir = tempy.directory();
-export let cache: FSCache = new FSCache(outputFS, cacheDir);
-cache.ensure();
-
 export const DEFAULT_OPTIONS: AtlaspackOptions = {
   cacheDir,
   parcelVersion: '',