@atlaspack/query 2.14.5-canary.2 → 2.14.5-canary.200

package/src/{index.js → index.ts}

@@ -1,10 +1,7 @@
-// @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';
@@ -18,98 +15,86 @@ const {
     requestGraphEdgeTypes,
   },
   LMDBLiteCache,
-} = 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;
-        }
-      }
+} = process.env.ATLASPACK_REGISTER_USE_SRC === 'true'
+  ? require('./deep-imports.ts')
+  : require('./deep-imports.js');
+
+export async function loadGraphs(cacheDir: string): Promise<{
+  // @ts-expect-error TS2749
+  assetGraph: AssetGraph | null | undefined;
+  // @ts-expect-error TS2749
+  bundleGraph: BundleGraph | null | undefined;
+  // @ts-expect-error TS2749
+  requestTracker: RequestTracker | null | undefined;
+  bundleInfo: Map<ContentKey, PackagedBundleInfo> | null | undefined;
+  cacheInfo: Map<string, Array<string | number>> | null | undefined;
+}> {
+  let cacheInfo: Map<string, Array<string | number>> = new Map();
+  const cache = new LMDBLiteCache(cacheDir);
+
+  let requestGraphBlob;
+  let requestGraphKey;
+  let bundleGraphBlob;
+  let assetGraphBlob;
+  for (let key of cache.keys()) {
+    if (key.startsWith('Asset/')) {
+      continue;
+    } else if (key.startsWith('PackagerRunner/')) {
+      continue;
     }
 
-    return result;
+    if (key.startsWith('RequestTracker/') && key.endsWith('/RequestGraph')) {
+      requestGraphBlob = key;
+      requestGraphKey = key.split('/').slice(0, -1).join('/');
+    }
+    if (key.startsWith('BundleGraph/')) {
+      bundleGraphBlob = key;
+    }
+    if (key.startsWith('AssetGraph/')) {
+      assetGraphBlob = key;
+    }
   }
 
-  let cacheInfo: Map<string, Array<string | number>> = new Map();
-
-  let {requestGraphBlob, bundleGraphBlob, assetGraphBlob} =
-    getMostRecentCacheBlobs();
-  const cache = new LMDBLiteCache(cacheDir);
+  console.log({requestGraphBlob, bundleGraphBlob, assetGraphBlob});
 
   // Get requestTracker
+  // @ts-expect-error TS7034
   let requestTracker;
-  if (requestGraphBlob) {
+  if (requestGraphBlob != null && requestGraphKey != null) {
     try {
-      let requestGraphKey = requestGraphBlob.slice(0, -'-0'.length);
       let date = Date.now();
+
+      const buffer = await cache.getBlob(requestGraphBlob);
+      const deserializer = new v8.Deserializer(buffer);
+      console.log(
+        'Wire format version stored',
+        deserializer.getWireFormatVersion(),
+      );
+
       let {requestGraph, bufferLength} = await readAndDeserializeRequestGraph(
         cache,
+        requestGraphBlob,
         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);
+    } catch (e: any) {
+      console.error('Error loading Request Graph\n', e);
     }
   }
 
   // Get bundleGraph
   let bundleGraph;
-  if (bundleGraphBlob) {
+  if (bundleGraphBlob != null) {
     try {
-      let file = await cache.getLargeBlob(
-        path.basename(bundleGraphBlob).slice(0, -'-0'.length),
-      );
+      let file = await cache.getBlob(bundleGraphBlob);
 
       let timeToDeserialize = Date.now();
       let obj = v8.deserialize(file);
@@ -119,19 +104,17 @@ export async function loadGraphs(cacheDir: string): Promise<{|
 
       cacheInfo.set('BundleGraph', [Buffer.byteLength(file)]);
       cacheInfo.get('BundleGraph')?.push(timeToDeserialize);
-    } catch (e) {
-      console.log('Error loading Bundle Graph\n', e);
+    } catch (e: any) {
+      console.error('Error loading Bundle Graph\n', e);
     }
   }
 
   // Get assetGraph
   let assetGraph;
-  if (assetGraphBlob) {
+  if (assetGraphBlob != null) {
     try {
       // TODO: this should be reviewed when `cachePerformanceImprovements` flag is removed, as we'll be writing files to LMDB cache instead of large blobs
-      let file = await cache.getLargeBlob(
-        path.basename(assetGraphBlob).slice(0, -'-0'.length),
-      );
+      let file = await cache.getBlob(assetGraphBlob);
 
       let timeToDeserialize = Date.now();
       let obj = v8.deserialize(file);
@@ -141,15 +124,19 @@ export async function loadGraphs(cacheDir: string): Promise<{|
 
       cacheInfo.set('AssetGraph', [Buffer.byteLength(file)]);
       cacheInfo.get('AssetGraph')?.push(timeToDeserialize);
-    } catch (e) {
-      console.log('Error loading Asset Graph\n', e);
+    } catch (e: any) {
+      console.error('Error loading Asset Graph\n', e);
     }
   }
 
   function getSubRequests(id: NodeId) {
-    return requestTracker.graph
-      .getNodeIdsConnectedFrom(id, requestGraphEdgeTypes.subrequest)
-      .map((n) => nullthrows(requestTracker.graph.getNode(n)));
+    return (
+      // @ts-expect-error TS7005
+      requestTracker.graph
+        .getNodeIdsConnectedFrom(id, requestGraphEdgeTypes.subrequest)
+        // @ts-expect-error TS7006
+        .map((n) => nullthrows(requestTracker.graph.getNode(n)))
+    );
   }
 
   // Load graphs by finding the main subrequests and loading their results
@@ -168,18 +155,18 @@ export async function loadGraphs(cacheDir: string): Promise<{|
     let buildRequestSubRequests = getSubRequests(buildRequestId);
 
     let writeBundlesRequest = buildRequestSubRequests.find(
+      // @ts-expect-error TS7006
       (n) => n.type === 1 && n.requestType === 11,
     );
     if (writeBundlesRequest != null) {
       invariant(writeBundlesRequest.type === 1);
-      // $FlowFixMe[incompatible-cast]
-      bundleInfo = (nullthrows(writeBundlesRequest.result): Map<
+      bundleInfo = nullthrows(writeBundlesRequest.result) as Map<
         ContentKey,
-        PackagedBundleInfo,
-      >);
+        PackagedBundleInfo
+      >;
     }
-  } catch (e) {
-    console.log('Error loading bundleInfo\n', e);
+  } catch (e: any) {
+    console.error('Error loading bundleInfo\n', e);
   }
 
   return {assetGraph, bundleGraph, requestTracker, bundleInfo, cacheInfo};

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../tsconfig.json",
+  "include": ["src"]
+}