@atlaspack/cache 3.1.1-canary.48 → 3.1.1-canary.481

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

@@ -1,22 +1,18 @@
-// @flow strict-local
-
 import {
   deserialize,
   registerSerializableClass,
   serialize,
 } from '@atlaspack/build-cache';
-import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {Lmdb} from '@atlaspack/rust';
 import type {FilePath} from '@atlaspack/types';
 import type {Cache} from './types';
 import type {Readable, Writable} from 'stream';
-import fs from 'fs';
+// @ts-expect-error TS7016
 import ncp from 'ncp';
 import {promisify} from 'util';
 import stream from 'stream';
 import path from 'path';
 import {NodeFS} from '@atlaspack/fs';
-// $FlowFixMe
 import packageJson from '../package.json';
 import {FSCache} from './FSCache';
 import {instrumentAsync} from '@atlaspack/logger';
@@ -84,19 +80,19 @@ export function open(
       asyncWrites: true,
       mapSize:
         process.env.ATLASPACK_BUILD_ENV === 'test'
-          ? 1024 * 1024 * 1024
+          ? 256 * 1024 * 1024
           : 1024 * 1024 * 1024 * 15,
     }),
   );
 }
 
-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;
@@ -129,9 +125,7 @@ export class LMDBLiteCache implements Cache {
   }
 
   async ensure(): Promise<void> {
-    if (!getFeatureFlag('cachePerformanceImprovements')) {
-      await this.fsCache.ensure();
-    }
+    await this.fsCache.ensure();
     await this.fs.mkdirp(this.cacheFilesDirectory);
     return Promise.resolve();
   }
@@ -150,7 +144,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);
@@ -159,29 +153,19 @@ 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 {
-    if (!getFeatureFlag('cachePerformanceImprovements')) {
-      return this.fs.createReadStream(path.join(this.dir, key));
-    }
-
-    return fs.createReadStream(this.getFileKey(key));
+    return this.fs.createReadStream(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 fs.promises.mkdir(path.dirname(filePath), {recursive: true});
-    return pipeline(stream, fs.createWriteStream(filePath));
+  setStream(key: string, stream: Readable): Promise<void> {
+    return pipeline(
+      stream,
+      this.fs.createWriteStream(path.join(this.dir, key)),
+    );
   }
 
   // eslint-disable-next-line require-await
@@ -201,51 +185,33 @@ 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));
   }
 
   hasLargeBlob(key: string): Promise<boolean> {
-    if (!getFeatureFlag('cachePerformanceImprovements')) {
-      return this.fsCache.hasLargeBlob(key);
-    }
-
-    return fs.promises
-      .access(this.getFileKey(key), fs.constants.F_OK)
-      .then(() => true)
-      .catch(() => false);
+    return this.fsCache.hasLargeBlob(key);
   }
 
   getLargeBlob(key: string): Promise<Buffer> {
-    if (!getFeatureFlag('cachePerformanceImprovements')) {
-      return this.fsCache.getLargeBlob(key);
-    }
-    return fs.promises.readFile(this.getFileKey(key));
+    return this.fsCache.getLargeBlob(key);
   }
 
-  async setLargeBlob(
+  setLargeBlob(
     key: string,
     contents: Buffer | string,
-    options?: {|signal?: AbortSignal|},
+    options?: {
+      signal?: AbortSignal;
+    },
   ): Promise<void> {
-    if (!getFeatureFlag('cachePerformanceImprovements')) {
-      return this.fsCache.setLargeBlob(key, contents, options);
-    }
-
-    const targetPath = this.getFileKey(key);
-    await fs.promises.mkdir(path.dirname(targetPath), {recursive: true});
-    return fs.promises.writeFile(targetPath, contents);
+    return this.fsCache.setLargeBlob(key, contents, options);
   }
 
   /**
    * @deprecated Use store.delete instead.
    */
   deleteLargeBlob(key: string): Promise<void> {
-    if (!getFeatureFlag('cachePerformanceImprovements')) {
-      return this.fsCache.deleteLargeBlob(key);
-    }
-
-    return this.store.delete(key);
+    return this.fsCache.deleteLargeBlob(key);
   }
 
   keys(): Iterable<string> {
@@ -253,9 +219,9 @@ export class LMDBLiteCache implements Cache {
   }
 
   async compact(targetPath: string): Promise<void> {
-    await fs.promises.mkdir(targetPath, {recursive: true});
+    await this.fs.mkdirp(targetPath);
 
-    const files = await fs.promises.readdir(this.dir);
+    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);

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.js → LMDBLiteCache.test.ts}

@@ -1,5 +1,3 @@
-// @flow
-
 import * as fs from 'fs';
 import * as path from 'path';
 import {tmpdir} from 'os';
@@ -12,7 +10,7 @@ import {initializeMonitoring} from '@atlaspack/rust';
 const cacheDir = path.join(tmpdir(), 'lmdb-lite-cache-tests');
 
 describe('LMDBLiteCache', () => {
-  let cache;
+  let cache: any;
 
   beforeEach(async () => {
     await fs.promises.rm(cacheDir, {recursive: true, force: true});
@@ -129,7 +127,7 @@ describe('LMDBLiteCache', () => {
       await cache.ensure();
       await cache.setBlob(`key${i}`, Buffer.from(serialize({value: i})));
 
-      await new Promise((resolve) => setTimeout(resolve, 10));
+      await new Promise((resolve: any) => setTimeout(resolve, 10));
     }
 
     const finalCache = new LMDBLiteCache(testDir);
@@ -144,7 +142,7 @@ describe('LMDBLiteCache', () => {
 
     try {
       initializeMonitoring();
-    } catch (error) {
+    } catch (error: any) {
       /* empty */
     }
 
@@ -165,8 +163,8 @@ describe('LMDBLiteCache', () => {
 
     const numWorkers = 10;
 
-    const workers = [];
-    const responsePromises = [];
+    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: {
@@ -175,16 +173,16 @@ describe('LMDBLiteCache', () => {
       });
       workers.push(worker);
 
-      const responsePromise = new Promise((resolve, reject) => {
+      const responsePromise = new Promise((resolve: any, reject: any) => {
         worker.addListener('error', (error: Error) => {
           reject(error);
         });
-        worker.addListener('message', (message) => {
+        worker.addListener('message', (message: any) => {
           resolve(message);
         });
       });
 
-      worker.addListener('message', (message) => {
+      worker.addListener('message', (message: any) => {
         // eslint-disable-next-line no-console
         console.log('Worker message', message);
       });
@@ -236,7 +234,7 @@ describe('LMDBLiteCache', () => {
         workerId: worker.threadId,
       });
 
-      await new Promise((resolve) => setTimeout(resolve, 500));
+      await new Promise((resolve: any) => setTimeout(resolve, 500));
       worker.terminate();
     }
   });

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"
+    }
+  ]
+}