@atlaspack/cache 3.1.1-canary.44 → 3.1.1-canary.46

package/lib/LMDBLiteCache.js

@@ -83,11 +83,6 @@ const ncpAsync = (0, _util().promisify)(_ncp().default);
 class LmdbWrapper {
   constructor(lmdb) {
     this.lmdb = lmdb;
-
-    // $FlowFixMe
-    this[Symbol.dispose] = () => {
-      this.lmdb.close();
-    };
   }
   has(key) {
     return this.lmdb.hasSync(key);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@atlaspack/cache",
   "description": "Interface for defining caches and file-system, IDB and LMDB implementations.",
-  "version": "3.1.1-canary.44+f4da1e120",
+  "version": "3.1.1-canary.46+1ef91fcc8",
   "license": "(MIT OR Apache-2.0)",
   "type": "commonjs",
   "publishConfig": {
@@ -23,12 +23,12 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3-canary.112+f4da1e120",
-    "@atlaspack/feature-flags": "2.14.1-canary.112+f4da1e120",
-    "@atlaspack/fs": "2.14.5-canary.44+f4da1e120",
-    "@atlaspack/logger": "2.14.5-canary.44+f4da1e120",
-    "@atlaspack/rust": "3.2.1-canary.44+f4da1e120",
-    "@atlaspack/utils": "2.14.5-canary.44+f4da1e120",
+    "@atlaspack/build-cache": "2.13.3-canary.114+1ef91fcc8",
+    "@atlaspack/feature-flags": "2.14.1-canary.114+1ef91fcc8",
+    "@atlaspack/fs": "2.14.5-canary.46+1ef91fcc8",
+    "@atlaspack/logger": "2.14.5-canary.46+1ef91fcc8",
+    "@atlaspack/rust": "3.2.1-canary.46+1ef91fcc8",
+    "@atlaspack/utils": "2.14.5-canary.46+1ef91fcc8",
     "ncp": "^2.0.0"
   },
   "devDependencies": {
@@ -37,5 +37,5 @@
   "browser": {
     "./src/IDBCache.js": "./src/IDBCache.browser.js"
   },
-  "gitHead": "f4da1e120e73eeb5e8b8927f05e88f04d6148c7b"
+  "gitHead": "1ef91fcc863fdd2831511937083dbbc1263b3d9d"
 }

package/src/LMDBLiteCache.js

@@ -36,11 +36,6 @@ export class LmdbWrapper {
 
   constructor(lmdb: Lmdb) {
     this.lmdb = lmdb;
-
-    // $FlowFixMe
-    this[Symbol.dispose] = () => {
-      this.lmdb.close();
-    };
   }
 
   has(key: string): boolean {

package/test/LMDBLiteCache.test.js

@@ -6,6 +6,8 @@ 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');
 
@@ -84,11 +86,158 @@ describe('LMDBLiteCache', () => {
     cache = new LMDBLiteCache(path.join(cacheDir, 'close_and_reopen_test'));
     await cache.ensure();
     await cache.setBlob('key', Buffer.from(serialize({value: 42})));
-    cache.getNativeRef().close();
     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) => 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) {
+      /* 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 = [];
+    const responsePromises = [];
+    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, reject) => {
+        worker.addListener('error', (error: Error) => {
+          reject(error);
+        });
+        worker.addListener('message', (message) => {
+          resolve(message);
+        });
+      });
+
+      worker.addListener('message', (message) => {
+        // 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) => 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);
+}