@atlaspack/query 2.12.1-canary.3354

package/src/deep-imports.js

@@ -0,0 +1,61 @@
+// @flow
+/* eslint-disable monorepo/no-internal-import */
+import typeof AssetGraph from '@atlaspack/core/src/AssetGraph.js';
+import typeof BundleGraph, {
+  bundleGraphEdgeTypes,
+} from '@atlaspack/core/src/BundleGraph.js';
+import typeof RequestTracker, {
+  RequestGraph,
+  readAndDeserializeRequestGraph,
+} from '@atlaspack/core/src/RequestTracker.js';
+import typeof {requestGraphEdgeTypes} from '@atlaspack/core/src/RequestTracker.js';
+import typeof {LMDBCache} from '@atlaspack/cache/src/LMDBCache.js';
+import typeof {Priority} from '@atlaspack/core/src/types.js';
+import typeof {fromProjectPathRelative} from '@atlaspack/core/src/projectPath.js';
+
+const v =
+  process.env.ATLASPACK_BUILD_ENV === 'production'
+    ? {
+        // Split up require specifier to outsmart packages/dev/babel-register/babel-plugin-module-translate.js
+        // $FlowFixMe(unsupported-syntax)
+        AssetGraph: require('@atlaspack/core' + '/lib/AssetGraph.js').default,
+        // $FlowFixMe(unsupported-syntax)
+        BundleGraph: require('@atlaspack/core' + '/lib/BundleGraph.js'),
+        // $FlowFixMe(unsupported-syntax)
+        RequestTracker: require('@atlaspack/core' + '/lib/RequestTracker.js'),
+        // $FlowFixMe(unsupported-syntax)
+        LMDBCache: require('@atlaspack/cache' + '/lib/LMDBCache.js').LMDBCache,
+        // $FlowFixMe(unsupported-syntax)
+        Priority: require('@atlaspack/core' + '/lib/types.js').Priority,
+        // $FlowFixMe(unsupported-syntax)
+        fromProjectPathRelative: require('@atlaspack/core' +
+          '/lib/projectPath.js').fromProjectPathRelative,
+      }
+    : {
+        AssetGraph: require('@atlaspack/core/src/AssetGraph.js').default,
+        BundleGraph: require('@atlaspack/core/src/BundleGraph.js'),
+        RequestTracker: require('@atlaspack/core/src/RequestTracker.js'),
+        LMDBCache: require('@atlaspack/cache/src/LMDBCache.js').LMDBCache,
+        Priority: require('@atlaspack/core/src/types.js').Priority,
+        fromProjectPathRelative: require('@atlaspack/core/src/projectPath.js')
+          .fromProjectPathRelative,
+      };
+
+module.exports = (v: {|
+  AssetGraph: AssetGraph,
+  BundleGraph: {
+    default: BundleGraph,
+    bundleGraphEdgeTypes: bundleGraphEdgeTypes,
+    ...
+  },
+  RequestTracker: {
+    default: RequestTracker,
+    readAndDeserializeRequestGraph: readAndDeserializeRequestGraph,
+    RequestGraph: RequestGraph,
+    requestGraphEdgeTypes: requestGraphEdgeTypes,
+    ...
+  },
+  LMDBCache: LMDBCache,
+  Priority: Priority,
+  fromProjectPathRelative: fromProjectPathRelative,
+|});

package/src/index.js

@@ -0,0 +1,185 @@
+// @flow strict-local
+/* eslint-disable no-console, monorepo/no-internal-import */
+import type {ContentKey, NodeId} from '@atlaspack/graph';
+import type {PackagedBundleInfo} from '@atlaspack/core/src/types';
+
+import fs from 'fs';
+import path from 'path';
+import v8 from 'v8';
+import nullthrows from 'nullthrows';
+import invariant from 'assert';
+
+const {
+  AssetGraph,
+  BundleGraph: {default: BundleGraph},
+  RequestTracker: {
+    default: RequestTracker,
+    readAndDeserializeRequestGraph,
+    requestGraphEdgeTypes,
+  },
+  LMDBCache,
+} = require('./deep-imports.js');
+
+export async function loadGraphs(cacheDir: string): Promise<{|
+  assetGraph: ?AssetGraph,
+  bundleGraph: ?BundleGraph,
+  requestTracker: ?RequestTracker,
+  bundleInfo: ?Map<ContentKey, PackagedBundleInfo>,
+  cacheInfo: ?Map<string, Array<string | number>>,
+|}> {
+  function getMostRecentCacheBlobs() {
+    let files = fs.readdirSync(cacheDir);
+
+    let result = {};
+
+    let blobsToFind: Array<{|
+      name: string,
+      check: (v: string) => boolean,
+      mtime?: Date,
+    |}> = [
+      {
+        name: 'requestGraphBlob',
+        check: basename =>
+          basename.startsWith('requestGraph-') &&
+          !basename.startsWith('requestGraph-nodes'),
+      },
+      {
+        name: 'bundleGraphBlob',
+        check: basename => basename.endsWith('BundleGraph-0'),
+      },
+      {
+        name: 'assetGraphBlob',
+        check: basename => basename.endsWith('AssetGraph-0'),
+      },
+    ];
+
+    for (let file of files) {
+      let basename = path.basename(file);
+      let match = blobsToFind.find(({check}) => check(basename));
+
+      if (match) {
+        let stat = fs.statSync(path.join(cacheDir, file));
+
+        if (!match.mtime || stat.mtime > match.mtime) {
+          match.mtime = stat.mtime;
+          result[match.name] = file;
+        }
+      }
+    }
+
+    return result;
+  }
+
+  let cacheInfo: Map<string, Array<string | number>> = new Map();
+
+  let {requestGraphBlob, bundleGraphBlob, assetGraphBlob} =
+    getMostRecentCacheBlobs();
+  const cache = new LMDBCache(cacheDir);
+
+  // Get requestTracker
+  let requestTracker;
+  if (requestGraphBlob) {
+    try {
+      let requestGraphKey = requestGraphBlob.slice(0, -'-0'.length);
+      let date = Date.now();
+      let {requestGraph, bufferLength} = await readAndDeserializeRequestGraph(
+        cache,
+        requestGraphKey,
+        requestGraphKey.replace('requestGraph-', ''),
+      );
+
+      requestTracker = new RequestTracker({
+        graph: requestGraph,
+        // $FlowFixMe
+        farm: null,
+        // $FlowFixMe
+        options: null,
+      });
+      let timeToDeserialize = Date.now() - date;
+      cacheInfo.set('RequestGraph', [bufferLength]);
+      cacheInfo.get('RequestGraph')?.push(timeToDeserialize);
+    } catch (e) {
+      console.log('Error loading Request Graph\n', e);
+    }
+  }
+
+  // Get bundleGraph
+  let bundleGraph;
+  if (bundleGraphBlob) {
+    try {
+      let file = await cache.getLargeBlob(
+        path.basename(bundleGraphBlob).slice(0, -'-0'.length),
+      );
+
+      let timeToDeserialize = Date.now();
+      let obj = v8.deserialize(file);
+      invariant(obj.bundleGraph != null);
+      bundleGraph = BundleGraph.deserialize(obj.bundleGraph.value);
+      timeToDeserialize = Date.now() - timeToDeserialize;
+
+      cacheInfo.set('BundleGraph', [Buffer.byteLength(file)]);
+      cacheInfo.get('BundleGraph')?.push(timeToDeserialize);
+    } catch (e) {
+      console.log('Error loading Bundle Graph\n', e);
+    }
+  }
+
+  // Get assetGraph
+  let assetGraph;
+  if (assetGraphBlob) {
+    try {
+      let file = await cache.getLargeBlob(
+        path.basename(assetGraphBlob).slice(0, -'-0'.length),
+      );
+
+      let timeToDeserialize = Date.now();
+      let obj = v8.deserialize(file);
+      invariant(obj.assetGraph != null);
+      assetGraph = AssetGraph.deserialize(obj.assetGraph.value);
+      timeToDeserialize = Date.now() - timeToDeserialize;
+
+      cacheInfo.set('AssetGraph', [Buffer.byteLength(file)]);
+      cacheInfo.get('AssetGraph')?.push(timeToDeserialize);
+    } catch (e) {
+      console.log('Error loading Asset Graph\n', e);
+    }
+  }
+
+  function getSubRequests(id: NodeId) {
+    return requestTracker.graph
+      .getNodeIdsConnectedFrom(id, requestGraphEdgeTypes.subrequest)
+      .map(n => nullthrows(requestTracker.graph.getNode(n)));
+  }
+
+  // Load graphs by finding the main subrequests and loading their results
+  let bundleInfo;
+  try {
+    invariant(requestTracker);
+    let buildRequestId = requestTracker.graph.getNodeIdByContentKey(
+      'atlaspack_build_request',
+    );
+    let buildRequestNode = nullthrows(
+      requestTracker.graph.getNode(buildRequestId),
+    );
+    invariant(
+      buildRequestNode.type === 1 && buildRequestNode.requestType === 1,
+    );
+    let buildRequestSubRequests = getSubRequests(buildRequestId);
+
+    let writeBundlesRequest = buildRequestSubRequests.find(
+      n => n.type === 1 && n.requestType === 11,
+    );
+    if (writeBundlesRequest != null) {
+      invariant(writeBundlesRequest.type === 1);
+      // $FlowFixMe[incompatible-cast]
+      bundleInfo = (nullthrows(writeBundlesRequest.result): Map<
+        ContentKey,
+        PackagedBundleInfo,
+      >);
+    }
+  } catch (e) {
+    console.log('Error loading bundleInfo\n', e);
+  }
+
+  return {assetGraph, bundleGraph, requestTracker, bundleInfo, cacheInfo};
+}