@atlaspack/cache 3.1.1-canary.3 → 3.1.1-canary.300

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import {
   deserialize,
   registerSerializableClass,
@@ -10,17 +8,17 @@ import {Lmdb} from '@atlaspack/rust';
 import type {FilePath} from '@atlaspack/types';
 import type {Cache} from './types';
 import type {Readable, Writable} from 'stream';
-
+// @ts-expect-error TS7016
+import ncp from 'ncp';
+import {promisify} from 'util';
 import stream from 'stream';
 import path from 'path';
-import {promisify} from 'util';
-
 import {NodeFS} from '@atlaspack/fs';
-
-// $FlowFixMe
 import packageJson from '../package.json';
-
 import {FSCache} from './FSCache';
+import {instrumentAsync} from '@atlaspack/logger';
+
+const ncpAsync = promisify(ncp);
 
 interface DBOpenOptions {
   name: string;
@@ -35,11 +33,6 @@ export class LmdbWrapper {
 
   constructor(lmdb: Lmdb) {
     this.lmdb = lmdb;
-
-    // $FlowFixMe
-    this[Symbol.dispose] = () => {
-      this.lmdb.close();
-    };
   }
 
   has(key: string): boolean {
@@ -60,7 +53,21 @@ export class LmdbWrapper {
     await this.lmdb.put(key, buffer);
   }
 
-  resetReadTxn() {}
+  *keys(): Iterable<string> {
+    const PAGE_SIZE = 10000000;
+
+    let currentKeys = this.lmdb.keysSync(0, PAGE_SIZE);
+    while (currentKeys.length > 0) {
+      for (const key of currentKeys) {
+        yield key;
+      }
+      currentKeys = this.lmdb.keysSync(currentKeys.length, PAGE_SIZE);
+    }
+  }
+
+  compact(targetPath: string) {
+    this.lmdb.compact(targetPath);
+  }
 }
 
 export function open(
@@ -80,23 +87,28 @@ export function open(
   );
 }
 
-const pipeline: (Readable, Writable) => Promise<void> = promisify(
+const pipeline: (arg1: Readable, arg2: Writable) => Promise<void> = promisify(
   stream.pipeline,
 );
 
-export type SerLMDBLiteCache = {|
-  dir: FilePath,
-|};
+export type SerLMDBLiteCache = {
+  dir: FilePath;
+};
 
 export class LMDBLiteCache implements Cache {
   fs: NodeFS;
   dir: FilePath;
   store: LmdbWrapper;
   fsCache: FSCache;
+  /**
+   * Directory where we store raw files.
+   */
+  cacheFilesDirectory: FilePath;
 
   constructor(cacheDir: FilePath) {
     this.fs = new NodeFS();
     this.dir = cacheDir;
+    this.cacheFilesDirectory = path.join(cacheDir, 'files');
     this.fsCache = new FSCache(this.fs, cacheDir);
 
     this.store = open(cacheDir, {
@@ -117,6 +129,7 @@ export class LMDBLiteCache implements Cache {
     if (!getFeatureFlag('cachePerformanceImprovements')) {
       await this.fsCache.ensure();
     }
+    await this.fs.mkdirp(this.cacheFilesDirectory);
     return Promise.resolve();
   }
 
@@ -134,7 +147,7 @@ export class LMDBLiteCache implements Cache {
     return Promise.resolve(this.store.has(key));
   }
 
-  get<T>(key: string): Promise<?T> {
+  get<T>(key: string): Promise<T | null | undefined> {
     let data = this.store.get(key);
     if (data == null) {
       return Promise.resolve(null);
@@ -143,19 +156,29 @@ export class LMDBLiteCache implements Cache {
     return Promise.resolve(deserialize(data));
   }
 
-  async set(key: string, value: mixed): Promise<void> {
+  async set(key: string, value: unknown): Promise<void> {
     await this.setBlob(key, serialize(value));
   }
 
   getStream(key: string): Readable {
-    return this.fs.createReadStream(path.join(this.dir, key));
+    if (!getFeatureFlag('cachePerformanceImprovements')) {
+      return this.fs.createReadStream(path.join(this.dir, key));
+    }
+
+    return this.fs.createReadStream(this.getFileKey(key));
   }
 
-  setStream(key: string, stream: Readable): Promise<void> {
-    return pipeline(
-      stream,
-      this.fs.createWriteStream(path.join(this.dir, key)),
-    );
+  async setStream(key: string, stream: Readable): Promise<void> {
+    if (!getFeatureFlag('cachePerformanceImprovements')) {
+      return pipeline(
+        stream,
+        this.fs.createWriteStream(path.join(this.dir, key)),
+      );
+    }
+
+    const filePath = this.getFileKey(key);
+    await this.fs.mkdirp(path.dirname(filePath));
+    return pipeline(stream, this.fs.createWriteStream(filePath));
   }
 
   // eslint-disable-next-line require-await
@@ -175,43 +198,39 @@ export class LMDBLiteCache implements Cache {
     await this.store.put(key, contents);
   }
 
-  getBuffer(key: string): Promise<?Buffer> {
+  getBuffer(key: string): Promise<Buffer | null | undefined> {
     return Promise.resolve(this.store.get(key));
   }
 
-  #getFilePath(key: string, index: number): string {
-    return path.join(this.dir, `${key}-${index}`);
-  }
-
   hasLargeBlob(key: string): Promise<boolean> {
     if (!getFeatureFlag('cachePerformanceImprovements')) {
       return this.fsCache.hasLargeBlob(key);
     }
-    return this.has(key);
+
+    return this.fs.exists(this.getFileKey(key));
   }
 
-  /**
-   * @deprecated Use getBlob instead.
-   */
   getLargeBlob(key: string): Promise<Buffer> {
     if (!getFeatureFlag('cachePerformanceImprovements')) {
       return this.fsCache.getLargeBlob(key);
     }
-    return Promise.resolve(this.getBlobSync(key));
+    return this.fs.readFile(this.getFileKey(key));
   }
 
-  /**
-   * @deprecated Use setBlob instead.
-   */
-  setLargeBlob(
+  async setLargeBlob(
     key: string,
     contents: Buffer | string,
-    options?: {|signal?: AbortSignal|},
+    options?: {
+      signal?: AbortSignal;
+    },
   ): Promise<void> {
     if (!getFeatureFlag('cachePerformanceImprovements')) {
       return this.fsCache.setLargeBlob(key, contents, options);
     }
-    return this.setBlob(key, contents);
+
+    const targetPath = this.getFileKey(key);
+    await this.fs.mkdirp(path.dirname(targetPath));
+    return this.fs.writeFile(targetPath, contents);
   }
 
   /**
@@ -225,12 +244,64 @@ export class LMDBLiteCache implements Cache {
     return this.store.delete(key);
   }
 
-  refresh(): void {
-    // Reset the read transaction for the store. This guarantees that
-    // the next read will see the latest changes to the store.
-    // Useful in scenarios where reads and writes are multi-threaded.
-    // See https://github.com/kriszyp/lmdb-js#resetreadtxn-void
-    this.store.resetReadTxn();
+  keys(): Iterable<string> {
+    return this.store.keys();
+  }
+
+  async compact(targetPath: string): Promise<void> {
+    await this.fs.mkdirp(targetPath);
+
+    const files = await this.fs.readdir(this.dir);
+    // copy all files except data.mdb and lock.mdb to the target path (recursive)
+    for (const file of files) {
+      const filePath = path.join(this.dir, file);
+
+      if (file === 'data.mdb' || file === 'lock.mdb') {
+        continue;
+      }
+
+      await ncpAsync(filePath, path.join(targetPath, file));
+    }
+
+    this.store.compact(path.join(targetPath, 'data.mdb'));
+  }
+
+  refresh(): void {}
+
+  /**
+   * Streams, packages are stored in files instead of LMDB.
+   *
+   * On this case, if a cache key happens to have a parent traversal, ../..
+   * it is treated specially
+   *
+   * That is, something/../something and something are meant to be different
+   * keys.
+   *
+   * Plus we do not want to store values outside of the cache directory.
+   */
+  getFileKey(key: string): string {
+    const cleanKey = key
+      .split('/')
+      .map((part) => {
+        if (part === '..') {
+          return '$$__parent_dir$$';
+        }
+        return part;
+      })
+      .join('/');
+    return path.join(this.cacheFilesDirectory, cleanKey);
+  }
+
+  async clear(): Promise<void> {
+    await instrumentAsync('LMDBLiteCache::clear', async () => {
+      const keys = await this.keys();
+      for (const key of keys) {
+        await this.store.delete(key);
+      }
+
+      await this.fs.rimraf(this.cacheFilesDirectory);
+      await this.fs.mkdirp(this.cacheFilesDirectory);
+    });
   }
 }
 

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

@@ -1,4 +1,2 @@
-// @flow strict-local
-
 // Node has a file size limit of 2 GB
 export const WRITE_LIMIT_CHUNK = 2 * 1024 ** 3;

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

@@ -1,5 +1,3 @@
-// @flow
-
 export * from './FSCache';
 export * from './IDBCache';
 export * from './LMDBLiteCache';

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

@@ -1,4 +1,3 @@
-// @flow
 import type {Cache} from '@atlaspack/types';
 
 export type {Cache};

package/test/LMDBLiteCache.test.ts

@@ -0,0 +1,241 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import {tmpdir} from 'os';
+import {LMDBLiteCache} from '../src/index';
+import {deserialize, serialize} from 'v8';
+import assert from 'assert';
+import {Worker} from 'worker_threads';
+import {initializeMonitoring} from '@atlaspack/rust';
+
+const cacheDir = path.join(tmpdir(), 'lmdb-lite-cache-tests');
+
+describe('LMDBLiteCache', () => {
+  let cache: any;
+
+  beforeEach(async () => {
+    await fs.promises.rm(cacheDir, {recursive: true, force: true});
+  });
+
+  it('can be constructed', async () => {
+    cache = new LMDBLiteCache(cacheDir);
+    await cache.ensure();
+  });
+
+  it('can retrieve keys', async () => {
+    cache = new LMDBLiteCache(cacheDir);
+    await cache.ensure();
+    await cache.setBlob('key', Buffer.from(serialize({value: 42})));
+    const buffer = await cache.getBlob('key');
+    const result = deserialize(buffer);
+    assert.equal(result.value, 42);
+  });
+
+  it('can retrieve keys synchronously', async () => {
+    cache = new LMDBLiteCache(path.join(cacheDir, 'retrieve_keys_test'));
+    await cache.ensure();
+    await cache.setBlob('key', Buffer.from(serialize({value: 42})));
+    const buffer = cache.getBlobSync('key');
+    const result = deserialize(buffer);
+    assert.equal(result.value, 42);
+  });
+
+  it('can iterate over keys', async () => {
+    cache = new LMDBLiteCache(path.join(cacheDir, 'keys_test'));
+    await cache.ensure();
+    await cache.setBlob('key1', Buffer.from(serialize({value: 42})));
+    await cache.setBlob('key2', Buffer.from(serialize({value: 43})));
+    const keys = cache.keys();
+    assert.deepEqual(Array.from(keys), ['key1', 'key2']);
+  });
+
+  it('can compact databases', async () => {
+    cache = new LMDBLiteCache(path.join(cacheDir, 'compact_test'));
+    await cache.ensure();
+    await cache.setBlob('key1', Buffer.from(serialize({value: 42})));
+    await cache.setBlob('key2', Buffer.from(serialize({value: 43})));
+    await cache.compact(path.join(cacheDir, 'compact_test_compacted'));
+
+    cache = new LMDBLiteCache(path.join(cacheDir, 'compact_test_compacted'));
+    await cache.ensure();
+    const keys = cache.keys();
+    assert.deepEqual(Array.from(keys), ['key1', 'key2']);
+  });
+
+  describe('getFileKey', () => {
+    it('should return the correct key', () => {
+      const target = path.join(cacheDir, 'test-file-keys');
+      const cache = new LMDBLiteCache(target);
+      const key = cache.getFileKey('key');
+      assert.equal(key, path.join(target, 'files', 'key'));
+    });
+
+    it('should return the correct key for a key with a parent traversal', () => {
+      const target = path.join(cacheDir, 'test-parent-keys');
+      cache = new LMDBLiteCache(target);
+      const key = cache.getFileKey('../../key');
+      assert.equal(
+        key,
+        path.join(target, 'files', '$$__parent_dir$$/$$__parent_dir$$/key'),
+      );
+    });
+  });
+
+  it('can be closed and re-opened', async () => {
+    cache = new LMDBLiteCache(path.join(cacheDir, 'close_and_reopen_test'));
+    await cache.ensure();
+    await cache.setBlob('key', Buffer.from(serialize({value: 42})));
+    cache = new LMDBLiteCache(path.join(cacheDir, 'close_and_reopen_test'));
+    await cache.ensure();
+    const buffer = await cache.getBlob('key');
+    const result = deserialize(buffer);
+    assert.equal(result.value, 42);
+  });
+
+  it('should NOT fail when trying to open the same database twice', async () => {
+    const testDir = path.join(cacheDir, 'double_open_test');
+    const cache1 = new LMDBLiteCache(testDir);
+    await cache1.ensure();
+
+    assert.doesNotThrow(() => {
+      new LMDBLiteCache(testDir);
+    });
+  });
+
+  it('should NOT fail when trying to open after GC', async () => {
+    const testDir = path.join(cacheDir, 'gc_test');
+
+    let cache1 = new LMDBLiteCache(testDir);
+    await cache1.ensure();
+    await cache1.setBlob('key', Buffer.from(serialize({value: 42})));
+
+    cache1 = null;
+
+    if (global.gc) {
+      global.gc();
+    }
+
+    assert.doesNotThrow(() => {
+      new LMDBLiteCache(testDir);
+    });
+  });
+
+  it('should handle rapid open/close cycles', async () => {
+    const testDir = path.join(cacheDir, 'rapid_cycles_test');
+
+    for (let i = 0; i < 10; i++) {
+      const cache = new LMDBLiteCache(testDir);
+      await cache.ensure();
+      await cache.setBlob(`key${i}`, Buffer.from(serialize({value: i})));
+
+      await new Promise((resolve: any) => setTimeout(resolve, 10));
+    }
+
+    const finalCache = new LMDBLiteCache(testDir);
+    await finalCache.ensure();
+    const buffer = await finalCache.getBlob('key9');
+    const result = deserialize(buffer);
+    assert.equal(result.value, 9);
+  });
+
+  it('should work when there are multiple node.js worker threads accessing the same database', async function () {
+    this.timeout(40000);
+
+    try {
+      initializeMonitoring();
+    } catch (error: any) {
+      /* empty */
+    }
+
+    const testDir = path.join(cacheDir, 'worker_threads_test');
+
+    let cache = new LMDBLiteCache(testDir);
+    await cache.set('main_thread_key', {
+      mainThreadId: 0,
+      hello: 'world',
+    });
+    setTimeout(() => {
+      cache = null;
+
+      if (global.gc) {
+        global.gc();
+      }
+    }, Math.random() * 300);
+
+    const numWorkers = 10;
+
+    const workers: Array<any> = [];
+    const responsePromises: Array<any> = [];
+    for (let i = 0; i < numWorkers; i++) {
+      const worker = new Worker(path.join(__dirname, 'workerThreadsTest.js'), {
+        workerData: {
+          cacheDir: testDir,
+        },
+      });
+      workers.push(worker);
+
+      const responsePromise = new Promise((resolve: any, reject: any) => {
+        worker.addListener('error', (error: Error) => {
+          reject(error);
+        });
+        worker.addListener('message', (message: any) => {
+          resolve(message);
+        });
+      });
+
+      worker.addListener('message', (message: any) => {
+        // eslint-disable-next-line no-console
+        console.log('Worker message', message);
+      });
+      worker.addListener('online', () => {
+        worker.postMessage({
+          type: 'go',
+        });
+      });
+
+      responsePromises.push(responsePromise);
+    }
+
+    // eslint-disable-next-line no-console
+    console.log('Waiting for responses');
+    const responses = await Promise.all(responsePromises);
+
+    // eslint-disable-next-line no-console
+    console.log('Responses received');
+    for (const [index, response] of responses.entries()) {
+      const worker = workers[index];
+
+      assert.deepEqual(
+        response,
+        {
+          mainThreadData: {
+            mainThreadId: 0,
+            hello: 'world',
+          },
+          workerId: worker.threadId,
+        },
+        `worker_${index} - Worker ${worker.threadId} should have received the correct data`,
+      );
+    }
+
+    // eslint-disable-next-line no-console
+    console.log('Getting main thread key');
+    cache = new LMDBLiteCache(testDir);
+    const data = await cache?.get('main_thread_key');
+    assert.deepEqual(data, {
+      mainThreadId: 0,
+      hello: 'world',
+    });
+
+    // eslint-disable-next-line no-console
+    console.log('Getting worker keys');
+    for (const worker of workers) {
+      const data = await cache?.get(`worker_key/${worker.threadId}`);
+      assert.deepEqual(data, {
+        workerId: worker.threadId,
+      });
+
+      await new Promise((resolve: any) => setTimeout(resolve, 500));
+      worker.terminate();
+    }
+  });
+});

package/test/workerThreadsTest.js

@@ -0,0 +1,42 @@
+/* eslint-disable no-inner-declarations */
+
+require('@atlaspack/babel-register');
+const {
+  workerData,
+  threadId,
+  parentPort,
+  isMainThread,
+} = require('worker_threads');
+const {LMDBLiteCache} = require('../src/index');
+
+if (!isMainThread) {
+  const cache = new LMDBLiteCache(workerData.cacheDir);
+
+  async function onMessage() {
+    try {
+      cache.set(`worker_key/${threadId}`, {
+        workerId: threadId,
+      });
+
+      const data = await cache.get('main_thread_key');
+
+      parentPort.postMessage({
+        mainThreadData: data,
+        workerId: threadId,
+      });
+
+      setTimeout(() => {
+        parentPort.postMessage({
+          type: 'close',
+          workerId: threadId,
+        });
+      }, Math.random() * 200);
+    } catch (error) {
+      parentPort.postMessage({
+        error: error.message,
+      });
+    }
+  }
+
+  parentPort.on('message', onMessage);
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "include": ["./src/", "./package.json"],
+  "compilerOptions": {
+    "composite": true
+  },
+  "references": [
+    {
+      "path": "../build-cache/tsconfig.json"
+    },
+    {
+      "path": "../feature-flags/tsconfig.json"
+    },
+    {
+      "path": "../fs/tsconfig.json"
+    },
+    {
+      "path": "../logger/tsconfig.json"
+    },
+    {
+      "path": "../rust/tsconfig.json"
+    },
+    {
+      "path": "../utils/tsconfig.json"
+    }
+  ]
+}