@atlaspack/core 2.12.1-canary.3354

package/test/PublicMutableBundleGraph.test.js

@@ -0,0 +1,192 @@
+// @flow strict-local
+
+import type {Dependency} from '@atlaspack/types';
+
+import assert from 'assert';
+import invariant from 'assert';
+import InternalBundleGraph from '../src/BundleGraph';
+import MutableBundleGraph from '../src/public/MutableBundleGraph';
+import {DEFAULT_ENV, DEFAULT_TARGETS, DEFAULT_OPTIONS} from './test-utils';
+import AssetGraph, {nodeFromAssetGroup} from '../src/AssetGraph';
+import {createAsset as _createAsset} from '../src/assetUtils';
+import {createDependency as _createDependency} from '../src/Dependency';
+import nullthrows from 'nullthrows';
+import {toProjectPath} from '../src/projectPath';
+
+function createAsset(opts) {
+  return _createAsset('/', opts);
+}
+
+function createDependency(opts) {
+  return _createDependency('/', opts);
+}
+
+const id1 = '0123456789abcdef0123456789abcdef';
+const id2 = '9876543210fedcba9876543210fedcba';
+
+describe('PublicMutableBundleGraph', () => {
+  it('creates publicIds for bundles', () => {
+    let internalBundleGraph = InternalBundleGraph.fromAssetGraph(
+      createMockAssetGraph(),
+      false,
+    );
+    let mutableBundleGraph = new MutableBundleGraph(
+      internalBundleGraph,
+      DEFAULT_OPTIONS,
+    );
+
+    mutableBundleGraph.traverse(node => {
+      if (
+        node.type === 'dependency' &&
+        mutableBundleGraph.getResolvedAsset(node.value)
+      ) {
+        let target = nullthrows(node.value.target);
+        let group = mutableBundleGraph.createBundleGroup(node.value, target);
+        let resolved = mutableBundleGraph.getResolvedAsset(node.value);
+        if (resolved != null) {
+          mutableBundleGraph.addBundleToBundleGroup(
+            mutableBundleGraph.createBundle({
+              entryAsset: resolved,
+              target,
+            }),
+            group,
+          );
+        }
+      }
+    });
+
+    assert.deepEqual(
+      internalBundleGraph.getBundles().map(b => b.publicId),
+      ['8LVYC', 'd7Pd5'],
+    );
+  });
+
+  it('is safe to add a bundle to a bundleGroup multiple times', () => {
+    let internalBundleGraph = InternalBundleGraph.fromAssetGraph(
+      createMockAssetGraph(),
+      false,
+    );
+    let mutableBundleGraph = new MutableBundleGraph(
+      internalBundleGraph,
+      DEFAULT_OPTIONS,
+    );
+
+    let dependency: Dependency;
+    mutableBundleGraph.traverse((node, _, actions) => {
+      if (node.type === 'dependency') {
+        dependency = node.value;
+        actions.stop();
+      }
+    });
+
+    invariant(dependency != null);
+
+    let target = nullthrows(dependency.target);
+    let bundleGroup = mutableBundleGraph.createBundleGroup(dependency, target);
+    let bundle = mutableBundleGraph.createBundle({
+      entryAsset: nullthrows(mutableBundleGraph.getResolvedAsset(dependency)),
+      target,
+    });
+
+    mutableBundleGraph.addBundleToBundleGroup(bundle, bundleGroup);
+    mutableBundleGraph.addBundleToBundleGroup(bundle, bundleGroup);
+  });
+});
+
+const stats = {size: 0, time: 0};
+function createMockAssetGraph() {
+  let graph = new AssetGraph();
+  graph.setRootConnections({
+    entries: [toProjectPath('/', '/index'), toProjectPath('/', '/index2')],
+  });
+
+  graph.resolveEntry(
+    toProjectPath('/', '/index'),
+    [
+      {
+        filePath: toProjectPath('/', '/path/to/index/src/main.js'),
+        packagePath: toProjectPath('/', '/path/to/index'),
+      },
+    ],
+    '1',
+  );
+  graph.resolveEntry(
+    toProjectPath('/', '/index2'),
+    [
+      {
+        filePath: toProjectPath('/', '/path/to/index/src/main2.js'),
+        packagePath: toProjectPath('/', '/path/to/index'),
+      },
+    ],
+    '2',
+  );
+  graph.resolveTargets(
+    {
+      filePath: toProjectPath('/', '/path/to/index/src/main.js'),
+      packagePath: toProjectPath('/', '/path/to/index'),
+    },
+    DEFAULT_TARGETS,
+    '3',
+  );
+  graph.resolveTargets(
+    {
+      filePath: toProjectPath('/', '/path/to/index/src/main2.js'),
+      packagePath: toProjectPath('/', '/path/to/index'),
+    },
+    DEFAULT_TARGETS,
+    '4',
+  );
+
+  let dep1 = createDependency({
+    specifier: 'path/to/index/src/main.js',
+    specifierType: 'esm',
+    needsStableName: true,
+    env: DEFAULT_ENV,
+    target: DEFAULT_TARGETS[0],
+  });
+  let dep2 = createDependency({
+    specifier: 'path/to/index/src/main2.js',
+    specifierType: 'esm',
+    needsStableName: true,
+    env: DEFAULT_ENV,
+    target: DEFAULT_TARGETS[0],
+  });
+
+  let filePath = toProjectPath('/', '/index.js');
+  let req1 = {filePath, env: DEFAULT_ENV};
+  graph.resolveDependency(dep1, nodeFromAssetGroup(req1).value, '5');
+  graph.resolveAssetGroup(
+    req1,
+    [
+      createAsset({
+        id: id1,
+        filePath,
+        type: 'js',
+        isSource: true,
+        stats,
+        env: DEFAULT_ENV,
+      }),
+    ],
+    '6',
+  );
+
+  filePath = toProjectPath('/', '/index2.js');
+  let req2 = {filePath, env: DEFAULT_ENV};
+  graph.resolveDependency(dep2, nodeFromAssetGroup(req2).value, '7');
+  graph.resolveAssetGroup(
+    req2,
+    [
+      createAsset({
+        id: id2,
+        filePath,
+        type: 'js',
+        isSource: true,
+        stats,
+        env: DEFAULT_ENV,
+      }),
+    ],
+    '8',
+  );
+
+  return graph;
+}

package/test/RequestTracker.test.js

@@ -0,0 +1,448 @@
+// @flow strict-local
+
+import assert from 'assert';
+import nullthrows from 'nullthrows';
+import RequestTracker, {type RunAPI} from '../src/RequestTracker';
+import WorkerFarm from '@atlaspack/workers';
+import {DEFAULT_OPTIONS} from './test-utils';
+import {INITIAL_BUILD} from '../src/constants';
+import {makeDeferredWithPromise} from '@atlaspack/utils';
+
+const options = DEFAULT_OPTIONS;
+const farm = new WorkerFarm({workerPath: require.resolve('../src/worker.js')});
+
+describe('RequestTracker', () => {
+  it('should not run requests that have not been invalidated', async () => {
+    let tracker = new RequestTracker({farm, options});
+    await tracker.runRequest({
+      id: 'abc',
+      type: 7,
+      run: () => {},
+      input: null,
+    });
+    let called = false;
+    await tracker.runRequest({
+      id: 'abc',
+      type: 7,
+      run: () => {
+        called = true;
+      },
+      input: null,
+    });
+    assert(called === false);
+  });
+
+  it('should rerun requests that have been invalidated', async () => {
+    let tracker = new RequestTracker({farm, options});
+    await tracker.runRequest({
+      id: 'abc',
+      type: 7,
+      run: () => {},
+      input: null,
+    });
+    tracker.graph.invalidateNode(
+      tracker.graph.getNodeIdByContentKey('abc'),
+      INITIAL_BUILD,
+    );
+    let called = false;
+    await tracker.runRequest({
+      id: 'abc',
+      type: 7,
+      run: () => {
+        called = true;
+      },
+      input: null,
+    });
+    assert(called === true);
+  });
+
+  it('should invalidate requests with invalidated subrequests', async () => {
+    let tracker = new RequestTracker({farm, options});
+    await tracker.runRequest({
+      id: 'abc',
+      type: 7,
+      run: async ({api}) => {
+        await api.runRequest({
+          id: 'xyz',
+          type: 7,
+          run: () => {},
+          input: null,
+        });
+      },
+      input: null,
+    });
+    tracker.graph.invalidateNode(
+      tracker.graph.getNodeIdByContentKey('xyz'),
+      INITIAL_BUILD,
+    );
+    assert(
+      tracker
+        .getInvalidRequests()
+        .map(req => req.id)
+        .includes('abc'),
+    );
+  });
+
+  it('should invalidate requests that failed', async () => {
+    let tracker = new RequestTracker({farm, options});
+    await tracker
+      .runRequest({
+        id: 'abc',
+        type: 7,
+        run: async () => {
+          await Promise.resolve();
+          throw new Error('woops');
+        },
+        input: null,
+      })
+      .then(null, () => {
+        /* do nothing */
+      });
+    assert(
+      tracker
+        .getInvalidRequests()
+        .map(req => req.id)
+        .includes('abc'),
+    );
+  });
+
+  it('should remove subrequests that are no longer called within a request', async () => {
+    let tracker = new RequestTracker({farm, options});
+    await tracker.runRequest({
+      id: 'abc',
+      type: 7,
+      run: async ({api}) => {
+        await api.runRequest({
+          id: 'xyz',
+          type: 7,
+          run: () => {},
+          input: null,
+        });
+      },
+      input: null,
+    });
+    let nodeId = nullthrows(tracker.graph.getNodeIdByContentKey('abc'));
+    tracker.graph.invalidateNode(nodeId, INITIAL_BUILD);
+    await tracker.runRequest({
+      id: 'abc',
+      type: 7,
+      run: async ({api}) => {
+        await api.runRequest({
+          id: '123',
+          type: 7,
+          run: () => {},
+          input: null,
+        });
+      },
+      input: null,
+    });
+    assert(!tracker.graph.hasContentKey('xyz'));
+  });
+
+  it('should return a cached result if it was stored', 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>, ...}) => {
+        let result = await Promise.resolve('hello');
+        api.storeResult(result);
+      },
+      input: null,
+    });
+    let result = await tracker.runRequest({
+      id: 'abc',
+      type: 7,
+      run: async () => {},
+      input: null,
+    });
+    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>, ...}) => {
+        let result = await Promise.resolve();
+        api.storeResult(result);
+      },
+      input: null,
+    });
+
+    await tracker.writeToCache();
+
+    assert(tracker.graph.cachedRequestChunks.size > 0);
+  });
+
+  it('should not write to cache when the abort controller aborts', async () => {
+    let tracker = new RequestTracker({farm, options});
+
+    const abortController = new AbortController();
+    abortController.abort();
+
+    await tracker.writeToCache(abortController.signal);
+
+    assert(tracker.graph.cachedRequestChunks.size === 0);
+  });
+
+  it('should not requeue requests if the previous request is still running', async () => {
+    let tracker = new RequestTracker({farm, options});
+
+    let lockA = makeDeferredWithPromise();
+    let lockB = makeDeferredWithPromise();
+
+    let requestA = tracker.runRequest({
+      id: 'abc',
+      type: 7,
+      // $FlowFixMe string isn't a valid result
+      run: async ({api}: {api: RunAPI<string>, ...}) => {
+        await lockA.promise;
+        api.storeResult('a');
+        return 'a';
+      },
+      input: null,
+    });
+
+    let calledB = false;
+    let requestB = tracker.runRequest({
+      id: 'abc',
+      type: 7,
+      // $FlowFixMe string isn't a valid result
+      run: async ({api}: {api: RunAPI<string>, ...}) => {
+        calledB = true;
+        await lockB.promise;
+        api.storeResult('b');
+        return 'b';
+      },
+      input: null,
+    });
+
+    lockA.deferred.resolve();
+    lockB.deferred.resolve();
+    let resultA = await requestA;
+    let resultB = await requestB;
+    assert.strictEqual(resultA, 'a');
+    assert.strictEqual(resultB, 'a');
+    assert.strictEqual(calledB, false);
+
+    let cachedResult = await tracker.runRequest({
+      id: 'abc',
+      type: 7,
+      run: () => {},
+      input: null,
+    });
+    assert.strictEqual(cachedResult, 'a');
+  });
+
+  it('should requeue requests if the previous request is still running but failed', async () => {
+    let tracker = new RequestTracker({farm, options});
+
+    let lockA = makeDeferredWithPromise();
+    let lockB = makeDeferredWithPromise();
+
+    let requestA = tracker
+      .runRequest({
+        id: 'abc',
+        type: 7,
+        run: async () => {
+          await lockA.promise;
+          throw new Error('whoops');
+        },
+        input: null,
+      })
+      .catch(() => {
+        // ignore
+      });
+
+    let requestB = tracker.runRequest({
+      id: 'abc',
+      type: 7,
+      // $FlowFixMe string isn't a valid result
+      run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+        await lockB.promise;
+        api.storeResult('b');
+      },
+      input: null,
+    });
+
+    lockA.deferred.resolve();
+    lockB.deferred.resolve();
+    await requestA;
+    await requestB;
+
+    let called = false;
+    let cachedResult = await tracker.runRequest({
+      id: 'abc',
+      type: 7,
+      run: () => {
+        called = true;
+      },
+      input: null,
+    });
+    assert.strictEqual(cachedResult, 'b');
+    assert.strictEqual(called, false);
+  });
+
+  it('should ignore stale node chunks from cache', async () => {
+    let tracker = new RequestTracker({farm, options});
+
+    // Set the nodes per blob low so we can ensure multiple files without
+    // creating 17,000 nodes
+    tracker.graph.nodesPerBlob = 2;
+
+    tracker.graph.addNode({type: 0, id: 'some-file-node-1'});
+    tracker.graph.addNode({type: 0, id: 'some-file-node-2'});
+    tracker.graph.addNode({type: 0, id: 'some-file-node-3'});
+    tracker.graph.addNode({type: 0, id: 'some-file-node-4'});
+    tracker.graph.addNode({type: 0, id: 'some-file-node-5'});
+
+    await tracker.writeToCache();
+
+    // Create a new request tracker that shouldn't look at the old cache files
+    tracker = new RequestTracker({farm, options});
+    assert.equal(tracker.graph.nodes.length, 0);
+
+    tracker.graph.addNode({type: 0, id: 'some-file-node-1'});
+    await tracker.writeToCache();
+
+    // Init a request tracker that should only read the relevant cache files
+    tracker = await RequestTracker.init({farm, options});
+    assert.equal(tracker.graph.nodes.length, 1);
+  });
+
+  it('should init with multiple node chunks', async () => {
+    let tracker = new RequestTracker({farm, options});
+
+    // Set the nodes per blob low so we can ensure multiple files without
+    // creating 17,000 nodes
+    tracker.graph.nodesPerBlob = 2;
+
+    tracker.graph.addNode({type: 0, id: 'some-file-node-1'});
+    tracker.graph.addNode({type: 0, id: 'some-file-node-2'});
+    tracker.graph.addNode({type: 0, id: 'some-file-node-3'});
+    tracker.graph.addNode({type: 0, id: 'some-file-node-4'});
+    tracker.graph.addNode({type: 0, id: 'some-file-node-5'});
+
+    await tracker.writeToCache();
+
+    tracker = await RequestTracker.init({farm, options});
+    assert.equal(tracker.graph.nodes.length, 5);
+  });
+
+  it('should write new nodes to cache', async () => {
+    let tracker = new RequestTracker({farm, options});
+
+    tracker.graph.addNode({
+      type: 0,
+      id: 'test-file',
+    });
+    await tracker.writeToCache();
+    assert.equal(tracker.graph.nodes.length, 1);
+
+    tracker.graph.addNode({
+      type: 0,
+      id: 'test-file-2',
+    });
+    await tracker.writeToCache();
+    assert.equal(tracker.graph.nodes.length, 2);
+
+    // Create a new tracker from cache
+    tracker = await RequestTracker.init({farm, options});
+
+    await tracker.writeToCache();
+    assert.equal(tracker.graph.nodes.length, 2);
+  });
+
+  it('should write updated nodes to cache', async () => {
+    let tracker = new RequestTracker({farm, options});
+
+    let contentKey = 'abc';
+    await tracker.runRequest({
+      id: contentKey,
+      type: 7,
+      // $FlowFixMe string isn't a valid result
+      run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+        let result = await Promise.resolve('a');
+        api.storeResult(result);
+      },
+      input: null,
+    });
+    assert.equal(await tracker.getRequestResult(contentKey), 'a');
+    await tracker.writeToCache();
+
+    await tracker.runRequest(
+      {
+        id: contentKey,
+        type: 7,
+        // $FlowFixMe string isn't a valid result
+        run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+          let result = await Promise.resolve('b');
+          api.storeResult(result);
+        },
+        input: null,
+      },
+      {force: true},
+    );
+    assert.equal(await tracker.getRequestResult(contentKey), 'b');
+    await tracker.writeToCache();
+
+    // Create a new tracker from cache
+    tracker = await RequestTracker.init({farm, options});
+
+    assert.equal(await tracker.getRequestResult(contentKey), 'b');
+  });
+
+  it('should write invalidated nodes to cache', async () => {
+    let tracker = new RequestTracker({farm, options});
+
+    let contentKey = 'abc';
+    await tracker.runRequest({
+      id: contentKey,
+      type: 7,
+      run: () => {},
+      input: null,
+    });
+    let nodeId = tracker.graph.getNodeIdByContentKey(contentKey);
+    assert.equal(tracker.graph.getNode(nodeId)?.invalidateReason, 0);
+    await tracker.writeToCache();
+
+    tracker.graph.invalidateNode(nodeId, 1);
+    assert.equal(tracker.graph.getNode(nodeId)?.invalidateReason, 1);
+    await tracker.writeToCache();
+
+    // Create a new tracker from cache
+    tracker = await RequestTracker.init({farm, options});
+
+    assert.equal(tracker.graph.getNode(nodeId)?.invalidateReason, 1);
+  });
+});