@atlaspack/query 2.12.1-canary.3354

package/lib/deep-imports.js

@@ -0,0 +1,19 @@
+"use strict";
+
+/* eslint-disable monorepo/no-internal-import */
+const v = {
+  // 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
+};
+module.exports = v;

package/lib/index.js

@@ -0,0 +1,181 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadGraphs = loadGraphs;
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _v() {
+  const data = _interopRequireDefault(require("v8"));
+  _v = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/* eslint-disable no-console, monorepo/no-internal-import */
+const {
+  AssetGraph,
+  BundleGraph: {
+    default: BundleGraph
+  },
+  RequestTracker: {
+    default: RequestTracker,
+    readAndDeserializeRequestGraph,
+    requestGraphEdgeTypes
+  },
+  LMDBCache
+} = require('./deep-imports.js');
+async function loadGraphs(cacheDir) {
+  let cacheInfo = new Map();
+  let {
+    requestGraphBlob,
+    bundleGraphBlob,
+    assetGraphBlob
+  } = function getMostRecentCacheBlobs() {
+    let files = _fs().default.readdirSync(cacheDir);
+    let result = {};
+    let blobsToFind = [{
+      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().default.basename(file);
+      let match = blobsToFind.find(({
+        check
+      }) => check(basename));
+      if (match) {
+        let stat = _fs().default.statSync(_path().default.join(cacheDir, file));
+        if (!match.mtime || stat.mtime > match.mtime) {
+          match.mtime = stat.mtime;
+          result[match.name] = file;
+        }
+      }
+    }
+    return result;
+  }();
+  const cache = new LMDBCache(cacheDir);
+
+  // Get requestTracker
+  let requestTracker;
+  if (requestGraphBlob) {
+    try {
+      var _cacheInfo$get;
+      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 = cacheInfo.get('RequestGraph')) === null || _cacheInfo$get === void 0 || _cacheInfo$get.push(timeToDeserialize);
+    } catch (e) {
+      console.log('Error loading Request Graph\n', e);
+    }
+  }
+
+  // Get bundleGraph
+  let bundleGraph;
+  if (bundleGraphBlob) {
+    try {
+      var _cacheInfo$get2;
+      let file = await cache.getLargeBlob(_path().default.basename(bundleGraphBlob).slice(0, -'-0'.length));
+      let timeToDeserialize = Date.now();
+      let obj = _v().default.deserialize(file);
+      (0, _assert().default)(obj.bundleGraph != null);
+      bundleGraph = BundleGraph.deserialize(obj.bundleGraph.value);
+      timeToDeserialize = Date.now() - timeToDeserialize;
+      cacheInfo.set('BundleGraph', [Buffer.byteLength(file)]);
+      (_cacheInfo$get2 = cacheInfo.get('BundleGraph')) === null || _cacheInfo$get2 === void 0 || _cacheInfo$get2.push(timeToDeserialize);
+    } catch (e) {
+      console.log('Error loading Bundle Graph\n', e);
+    }
+  }
+
+  // Get assetGraph
+  let assetGraph;
+  if (assetGraphBlob) {
+    try {
+      var _cacheInfo$get3;
+      let file = await cache.getLargeBlob(_path().default.basename(assetGraphBlob).slice(0, -'-0'.length));
+      let timeToDeserialize = Date.now();
+      let obj = _v().default.deserialize(file);
+      (0, _assert().default)(obj.assetGraph != null);
+      assetGraph = AssetGraph.deserialize(obj.assetGraph.value);
+      timeToDeserialize = Date.now() - timeToDeserialize;
+      cacheInfo.set('AssetGraph', [Buffer.byteLength(file)]);
+      (_cacheInfo$get3 = cacheInfo.get('AssetGraph')) === null || _cacheInfo$get3 === void 0 || _cacheInfo$get3.push(timeToDeserialize);
+    } catch (e) {
+      console.log('Error loading Asset Graph\n', e);
+    }
+  }
+  function getSubRequests(id) {
+    return requestTracker.graph.getNodeIdsConnectedFrom(id, requestGraphEdgeTypes.subrequest).map(n => (0, _nullthrows().default)(requestTracker.graph.getNode(n)));
+  }
+
+  // Load graphs by finding the main subrequests and loading their results
+  let bundleInfo;
+  try {
+    (0, _assert().default)(requestTracker);
+    let buildRequestId = requestTracker.graph.getNodeIdByContentKey('atlaspack_build_request');
+    let buildRequestNode = (0, _nullthrows().default)(requestTracker.graph.getNode(buildRequestId));
+    (0, _assert().default)(buildRequestNode.type === 1 && buildRequestNode.requestType === 1);
+    let buildRequestSubRequests = getSubRequests(buildRequestId);
+    let writeBundlesRequest = buildRequestSubRequests.find(n => n.type === 1 && n.requestType === 11);
+    if (writeBundlesRequest != null) {
+      (0, _assert().default)(writeBundlesRequest.type === 1);
+      // $FlowFixMe[incompatible-cast]
+      bundleInfo = (0, _nullthrows().default)(writeBundlesRequest.result);
+    }
+  } catch (e) {
+    console.log('Error loading bundleInfo\n', e);
+  }
+  return {
+    assetGraph,
+    bundleGraph,
+    requestTracker,
+    bundleInfo,
+    cacheInfo
+  };
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@atlaspack/query",
+  "version": "2.12.1-canary.3354+7bb54d46a",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "prepack": "./ensure-no-dev-lib.sh",
+    "dev:prepare": "rimraf ./lib/ && mkdir -p lib && cp ./bin/dev-bin.js ./lib/bin.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/atlassian-labs/atlaspack.git"
+  },
+  "bin": {
+    "atlaspack-query": "bin/atlaspack-query.js"
+  },
+  "main": "src/index.js",
+  "dependencies": {
+    "@atlaspack/cache": "2.12.1-canary.3354+7bb54d46a",
+    "@atlaspack/core": "2.12.1-canary.3354+7bb54d46a",
+    "@atlaspack/graph": "3.2.1-canary.3354+7bb54d46a",
+    "nullthrows": "^1.1.1",
+    "table": "^6.8.1",
+    "v8-compile-cache": "^2.0.0"
+  },
+  "devDependencies": {
+    "@atlaspack/babel-register": "2.12.0",
+    "@babel/core": "^7.22.11",
+    "rimraf": "^5.0.5"
+  },
+  "gitHead": "7bb54d46a00c5ba9cdbc2ee426dcbe82c8d79a3e"
+}

package/src/bin.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+'use strict';
+
+if (
+  process.env.ATLASPACK_BUILD_ENV !== 'production' ||
+  process.env.ATLASPACK_SELF_BUILD
+) {
+  require('@atlaspack/babel-register');
+}
+
+const run = require('./cli').run;
+require('v8-compile-cache');
+
+run(process.argv.slice(2));