@atlaspack/core 2.16.2-canary.27 → 2.16.2-canary.270

package/test/{RequestTracker.test.js → RequestTracker.test.ts}

@@ -1,23 +1,53 @@
-// @flow strict-local
-
 import assert from 'assert';
 import nullthrows from 'nullthrows';
 import RequestTracker, {
-  type RunAPI,
+  RunAPI,
   cleanUpOrphans,
+  runInvalidation,
+  getBiggestFSEventsInvalidations,
+  invalidateRequestGraphFSEvents,
+  requestTypes,
 } 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;
-const farm = new WorkerFarm({workerPath: require.resolve('../src/worker')});
+import sinon from 'sinon';
+import type {AtlaspackOptions} from '../src/types';
+import createAtlaspackBuildRequest from '../src/requests/AtlaspackBuildRequest';
+import Atlaspack from '../src/Atlaspack';
+import {MemoryFS, NodeFS} from '@atlaspack/fs';
+import {OverlayFS} from '../../fs/src/OverlayFS';
+import path from 'path';
+import createAssetGraphRequest from '../src/requests/AssetGraphRequest';
+
+const options = {
+  ...DEFAULT_OPTIONS,
+  cache: new LMDBLiteCache(DEFAULT_OPTIONS.cacheDir),
+} as const;
 
 describe('RequestTracker', () => {
+  let farm: any;
+  before(() => {
+    farm = new WorkerFarm({workerPath: require.resolve('../src/worker')});
+  });
+
+  beforeEach(async () => {
+    await options.cache.ensure();
+
+    for (const key of options.cache.keys()) {
+      await options.cache.getNativeRef().delete(key);
+    }
+  });
+
+  after(() => {
+    farm.end();
+  });
+
   it('should not run requests that have not been invalidated', async () => {
     let tracker = new RequestTracker({farm, options});
     await tracker.runRequest({
@@ -67,7 +97,7 @@ describe('RequestTracker', () => {
     await tracker.runRequest({
       id: 'abc',
       type: 7,
-      run: async ({api}) => {
+      run: async ({api}: any) => {
         await api.runRequest({
           id: 'xyz',
           type: 7,
@@ -84,7 +114,7 @@ describe('RequestTracker', () => {
     assert(
       tracker
         .getInvalidRequests()
-        .map((req) => req.id)
+        .map((req: any) => req.id)
         .includes('abc'),
     );
   });
@@ -107,7 +137,7 @@ describe('RequestTracker', () => {
     assert(
       tracker
         .getInvalidRequests()
-        .map((req) => req.id)
+        .map((req: any) => req.id)
         .includes('abc'),
     );
   });
@@ -117,7 +147,7 @@ describe('RequestTracker', () => {
     await tracker.runRequest({
       id: 'abc',
       type: 7,
-      run: async ({api}) => {
+      run: async ({api}: any) => {
         await api.runRequest({
           id: 'xyz',
           type: 7,
@@ -132,7 +162,7 @@ describe('RequestTracker', () => {
     await tracker.runRequest({
       id: 'abc',
       type: 7,
-      run: async ({api}) => {
+      run: async ({api}: any) => {
         await api.runRequest({
           id: '123',
           type: 7,
@@ -150,8 +180,7 @@ describe('RequestTracker', () => {
     await tracker.runRequest({
       id: 'abc',
       type: 7,
-      // $FlowFixMe string isn't a valid result
-      run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+      run: async ({api}: {api: RunAPI<string | undefined>}) => {
         let result = await Promise.resolve('hello');
         api.storeResult(result);
       },
@@ -166,39 +195,13 @@ describe('RequestTracker', () => {
     assert(result === 'hello');
   });
 
-  it('should reject all in progress requests when the abort controller aborts', async () => {
-    let tracker = new RequestTracker({farm, options});
-    let p = tracker
-      .runRequest({
-        id: 'abc',
-        type: 7,
-        run: async () => {
-          await Promise.resolve('hello');
-        },
-        input: null,
-      })
-      .then(null, () => {
-        /* do nothing */
-      });
-    // $FlowFixMe
-    tracker.setSignal({aborted: true});
-    await p;
-    assert(
-      tracker
-        .getInvalidRequests()
-        .map((req) => req.id)
-        .includes('abc'),
-    );
-  });
-
   it('should write cache to disk and store index', async () => {
     let tracker = new RequestTracker({farm, options});
 
     await tracker.runRequest({
       id: 'abc',
       type: 7,
-      // $FlowFixMe string isn't a valid result
-      run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+      run: async ({api}: {api: RunAPI<string | undefined>}) => {
         let result = await Promise.resolve();
         api.storeResult(result);
       },
@@ -230,8 +233,7 @@ describe('RequestTracker', () => {
     let requestA = tracker.runRequest({
       id: 'abc',
       type: 7,
-      // $FlowFixMe string isn't a valid result
-      run: async ({api}: {api: RunAPI<string>, ...}) => {
+      run: async ({api}: {api: RunAPI<string>}) => {
         await lockA.promise;
         api.storeResult('a');
         return 'a';
@@ -243,8 +245,7 @@ describe('RequestTracker', () => {
     let requestB = tracker.runRequest({
       id: 'abc',
       type: 7,
-      // $FlowFixMe string isn't a valid result
-      run: async ({api}: {api: RunAPI<string>, ...}) => {
+      run: async ({api}: {api: RunAPI<string>}) => {
         calledB = true;
         await lockB.promise;
         api.storeResult('b');
@@ -293,8 +294,7 @@ describe('RequestTracker', () => {
     let requestB = tracker.runRequest({
       id: 'abc',
       type: 7,
-      // $FlowFixMe string isn't a valid result
-      run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+      run: async ({api}: {api: RunAPI<string | undefined>}) => {
         await lockB.promise;
         api.storeResult('b');
       },
@@ -396,8 +396,7 @@ describe('RequestTracker', () => {
     await tracker.runRequest({
       id: contentKey,
       type: 7,
-      // $FlowFixMe string isn't a valid result
-      run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+      run: async ({api}: {api: RunAPI<string | undefined>}) => {
         let result = await Promise.resolve('a');
         api.storeResult(result);
       },
@@ -410,8 +409,7 @@ describe('RequestTracker', () => {
       {
         id: contentKey,
         type: 7,
-        // $FlowFixMe string isn't a valid result
-        run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+        run: async ({api}: {api: RunAPI<string | undefined>}) => {
           let result = await Promise.resolve('b');
           api.storeResult(result);
         },
@@ -453,7 +451,7 @@ describe('RequestTracker', () => {
   });
 
   describe('respondToFSEvents', () => {
-    [true, false].forEach((value) => {
+    [true, false].forEach((value: any) => {
       beforeEach(() => {
         setFeatureFlags({
           ...DEFAULT_FEATURE_FLAGS,
@@ -473,8 +471,7 @@ describe('RequestTracker', () => {
           await tracker.runRequest({
             id: 'abc',
             type: 7,
-            // $FlowFixMe string isn't a valid result
-            run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+            run: async ({api}: {api: RunAPI<string | undefined>}) => {
               api.invalidateOnFileUpdate(toProjectPath('', 'my-file'));
               let result = await Promise.resolve('hello');
               api.storeResult(result);
@@ -482,7 +479,7 @@ describe('RequestTracker', () => {
             input: null,
           });
           const requestId = tracker.graph.getNodeIdByContentKey('abc');
-          const invalidated = await tracker.respondToFSEvents(
+          const {didInvalidate: invalidated} = await tracker.respondToFSEvents(
             [
               {
                 type: 'update',
@@ -506,8 +503,7 @@ describe('RequestTracker', () => {
           await tracker.runRequest({
             id: 'abc',
             type: 7,
-            // $FlowFixMe string isn't a valid result
-            run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+            run: async ({api}: {api: RunAPI<string | undefined>}) => {
               api.invalidateOnFileCreate({
                 fileName: 'package.json',
                 aboveFilePath: toProjectPath(
@@ -521,7 +517,7 @@ describe('RequestTracker', () => {
             input: null,
           });
           const requestId = tracker.graph.getNodeIdByContentKey('abc');
-          const invalidated = await tracker.respondToFSEvents(
+          const {didInvalidate: invalidated} = await tracker.respondToFSEvents(
             [
               {
                 type: 'create',
@@ -542,6 +538,171 @@ describe('RequestTracker', () => {
       });
     });
   });
+
+  describe('incremental bundling', () => {
+    async function runIncrementalBundlingScenario(
+      incrementalBundlingVersioning: boolean,
+    ) {
+      const fs = new OverlayFS(new MemoryFS(farm), new NodeFS());
+      const appRoot = __dirname;
+      await fs.mkdirp(path.join(appRoot, 'app'));
+      await fs.writeFile(path.join(appRoot, 'app', 'package.json'), '{}');
+      await fs.writeFile(path.join(appRoot, 'app', '.git'), '');
+      await fs.writeFile(
+        path.join(appRoot, 'app', '.parcelrc'),
+        '{"extends":"@atlaspack/config-default"}',
+      );
+      await fs.writeFile(
+        path.join(appRoot, 'app', 'target.js'),
+        'console.log("hello")',
+      );
+
+      const atlaspack = new Atlaspack({
+        featureFlags: {
+          incrementalBundlingVersioning,
+        },
+        workerFarm: farm,
+        entries: [path.join(appRoot, 'app', 'target.js')],
+        cache: new LMDBLiteCache(DEFAULT_OPTIONS.cacheDir),
+        inputFS: fs,
+        outputFS: fs,
+      });
+      await atlaspack._init();
+      const options = atlaspack._getResolvedAtlaspackOptions();
+      const tracker = new RequestTracker({farm, options});
+      let {ref: optionsRef} = await farm.createSharedReference(options, false);
+
+      const getAssetRequests = () =>
+        runRequestSpy
+          .getCalls()
+          .map((call: any) => call.args[0])
+          .filter(
+            (request: any) => request.type === requestTypes.asset_request,
+          );
+
+      // Running the build once builds one asset
+      const runRequestSpy = sinon.spy(tracker, 'runRequest');
+      await tracker.runRequest(
+        createAtlaspackBuildRequest({
+          optionsRef,
+          requestedAssetIds: new Set(),
+        }),
+      );
+      assert.equal(getAssetRequests().length, 1);
+      runRequestSpy.resetHistory();
+
+      // Running the build again with no invalidations does not build any assets
+      await tracker.runRequest(
+        createAtlaspackBuildRequest({
+          optionsRef,
+          requestedAssetIds: new Set(),
+        }),
+      );
+      assert.equal(getAssetRequests().length, 0);
+      runRequestSpy.resetHistory();
+
+      // Running the build again with a file change builds the asset again
+      tracker.respondToFSEvents(
+        [
+          {
+            type: 'update',
+            path: path.join(appRoot, 'app', 'target.js'),
+          },
+        ],
+        Number.MAX_VALUE,
+      );
+      await tracker.runRequest(
+        createAtlaspackBuildRequest({
+          optionsRef,
+          requestedAssetIds: new Set(),
+        }),
+      );
+      assert.equal(getAssetRequests().length, 1);
+      runRequestSpy.resetHistory();
+
+      // Run the asset graph request, but not bundling
+      await fs.writeFile(
+        path.join(appRoot, 'app', 'target.js'),
+        'require("./dep.js")',
+      );
+      await fs.writeFile(
+        path.join(appRoot, 'app', 'dep.js'),
+        'console.log("dep")',
+      );
+      tracker.respondToFSEvents(
+        [
+          {
+            type: 'update',
+            path: path.join(appRoot, 'app', 'target.js'),
+          },
+        ],
+        Number.MAX_VALUE,
+      );
+      const assetGraphRequestResult = await tracker.runRequest(
+        createAssetGraphRequest({
+          name: 'Main',
+          entries: [
+            toProjectPath(
+              path.join(appRoot, 'app'),
+              path.join(appRoot, 'app', 'target.js'),
+            ),
+          ],
+          optionsRef,
+          shouldBuildLazily: false,
+          lazyIncludes: [],
+          lazyExcludes: [],
+          requestedAssetIds: new Set(),
+        }),
+      );
+      assert.equal(getAssetRequests().length, 2);
+      assert.equal(
+        assetGraphRequestResult.assetGraph.safeToIncrementallyBundle,
+        false,
+      );
+
+      // Now make another change
+      tracker.respondToFSEvents(
+        [
+          {
+            type: 'update',
+            path: path.join(appRoot, 'app', 'target.js'),
+          },
+          {
+            type: 'update',
+            path: path.join(appRoot, 'app', 'dep.js'),
+          },
+        ],
+        Number.MAX_VALUE,
+      );
+      // And run the build again
+
+      if (!incrementalBundlingVersioning) {
+        await assert.rejects(async () => {
+          await tracker.runRequest(
+            createAtlaspackBuildRequest({
+              optionsRef,
+              requestedAssetIds: new Set(),
+            }),
+          );
+        });
+      } else {
+        await tracker.runRequest(
+          createAtlaspackBuildRequest({
+            optionsRef,
+            requestedAssetIds: new Set(),
+          }),
+        );
+      }
+    }
+
+    it('throws a content key not found exception without bundling versioning', async () => {
+      await runIncrementalBundlingScenario(false);
+    });
+
+    it('works fine with bundling versioning', async () => {
+      await runIncrementalBundlingScenario(true);
+    });
+  });
 });
 
 describe('cleanUpOrphans', () => {
@@ -562,8 +723,8 @@ root --- node1 --- node2 ----------- orphan1 --- orphan2
 
      */
 
-    const getNonNullNodes = (graph) =>
-      graph.nodes.filter((node) => node != null);
+    const getNonNullNodes = (graph: any) =>
+      graph.nodes.filter((node: any) => node != null);
 
     graph.addEdge(root, node1);
     graph.addEdge(node1, node2);
@@ -584,3 +745,97 @@ 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(),
+    } as const;
+
+    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(),
+    } as const;
+
+    requestGraph.respondToFSEvents.returns({
+      invalidationsByPath: new Map([
+        ['file-1', 10],
+        ['file-2', 5000],
+        ['file-3', 8000],
+      ]),
+    });
+    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},
+    ]);
+  });
+});