perf: single cache file

deno_dir_test.ts

@@ -57,7 +57,9 @@ export * from "./glob.ts";
     deps.set(url, expectedHeaders, new TextEncoder().encode(expectedText));
     const headers = deps.getHeaders(url)!;
     assertEquals(headers, expectedHeaders);
-    const text = new TextDecoder().decode(deps.get(url, undefined));
+    const cacheEntry = deps.get(url)!;
+    assertEquals(cacheEntry.headers, expectedHeaders);
+    const text = new TextDecoder().decode(cacheEntry.content);
     assertEquals(text, expectedText);
 
     // ok
@@ -78,17 +80,15 @@ export * from "./glob.ts";
 });
 
 Deno.test({
-  name: "HttpCache - global cache - allowCopyGlobalToLocal",
+  name: "HttpCache - global cache - get",
   async fn() {
     const denoDir = new DenoDir();
     const url = new URL("https://deno.land/std@0.140.0/path/mod.ts");
     const deps = await denoDir.createHttpCache();
     // disallow will still work because we're using a global cache
     // which is not affected by this option
-    const text = await deps.get(url, {
-      allowCopyGlobalToLocal: false,
-    });
-    assertEquals(text!.length, 820);
+    const entry = await deps.get(url);
+    assertEquals(entry!.content.length, 820);
   },
 });
 
@@ -98,22 +98,23 @@ Deno.test({
     await withTempDir(async (tempDir) => {
       const denoDir = new DenoDir();
       const url = new URL("https://deno.land/std@0.140.0/path/mod.ts");
-      const deps = await denoDir.createHttpCache({
-        vendorRoot: tempDir,
-      });
-      // disallow
+
+      // disallow copy from global to local because readonly
       {
-        const text = deps.get(url, {
-          allowCopyGlobalToLocal: false,
+        using deps = await denoDir.createHttpCache({
+          vendorRoot: tempDir,
+          readOnly: true,
         });
+        const text = deps.get(url);
         assertEquals(text, undefined);
       }
-      // allow
+      // this should be fine though
       {
-        const text = deps.get(url, {
-          allowCopyGlobalToLocal: true,
+        using deps = await denoDir.createHttpCache({
+          vendorRoot: tempDir,
         });
-        assertEquals(text!.length, 820);
+        const entry = deps.get(url);
+        assertEquals(entry!.content.length, 820);
       }
     });
   },

file_fetcher.ts

@@ -168,27 +168,23 @@ export class FileFetcher {
     options: ResolvedFetchOptions,
     httpCache: HttpCache,
   ): LoadResponse | undefined {
-    const headers = httpCache.getHeaders(specifier);
-    if (!headers) {
+    const cacheEntry = httpCache.get(specifier, options);
+    if (!cacheEntry) {
       return undefined;
     }
-    const location = headers["location"];
+    const location = cacheEntry.headers["location"];
     if (location != null && location.length > 0) {
       const redirect = new URL(location, specifier);
       return {
         kind: "redirect",
         specifier: redirect.toString(),
       };
     }
-    const content = httpCache.get(specifier, options);
-    if (content == null) {
-      return undefined;
-    }
     return {
       kind: "module",
       specifier: specifier.toString(),
-      headers,
-      content,
+      headers: cacheEntry.headers,
+      content: cacheEntry.content,
     };
   }
 

http_cache.ts

@@ -19,8 +19,11 @@ export interface HttpCacheGetOptions {
    * global cache (DENO_DIR) and not the local cache (vendor folder).
    */
   checksum?: string;
-  /** Allow copying from the global to the local cache (vendor folder). */
-  allowCopyGlobalToLocal?: boolean;
+}
+
+export interface HttpCacheEntry {
+  headers: Record<string, string>;
+  content: Uint8Array;
 }
 
 export class HttpCache implements Disposable {
@@ -48,7 +51,11 @@ export class HttpCache implements Disposable {
 
     let cache: LocalHttpCache | GlobalHttpCache;
     if (options.vendorRoot != null) {
-      cache = LocalHttpCache.new(options.vendorRoot, options.root);
+      cache = LocalHttpCache.new(
+        options.vendorRoot,
+        options.root,
+        /* allow global to local copy */ !options.readOnly,
+      );
     } else {
       cache = GlobalHttpCache.new(options.root);
     }
@@ -73,11 +80,10 @@ export class HttpCache implements Disposable {
   get(
     url: URL,
     options?: HttpCacheGetOptions,
-  ): Uint8Array | undefined {
-    const data = this.#cache.getFileBytes(
+  ): HttpCacheEntry | undefined {
+    const data = this.#cache.get(
       url.toString(),
       options?.checksum,
-      options?.allowCopyGlobalToLocal ?? true,
     );
     return data == null ? undefined : data;
   }

lib/deno_cache_dir.generated.d.ts

@@ -45,11 +45,10 @@ export class GlobalHttpCache {
   getHeaders(url: string): any;
 /**
 * @param {string} url
-* @param {string | undefined} maybe_checksum
-* @param {boolean} allow_global_to_local_copy
+* @param {string | undefined} [maybe_checksum]
 * @returns {any}
 */
-  getFileBytes(url: string, maybe_checksum: string | undefined, allow_global_to_local_copy: boolean): any;
+  get(url: string, maybe_checksum?: string): any;
 /**
 * @param {string} url
 * @param {any} headers
@@ -64,21 +63,21 @@ export class LocalHttpCache {
 /**
 * @param {string} local_path
 * @param {string} global_path
+* @param {boolean} allow_global_to_local_copy
 * @returns {LocalHttpCache}
 */
-  static new(local_path: string, global_path: string): LocalHttpCache;
+  static new(local_path: string, global_path: string, allow_global_to_local_copy: boolean): LocalHttpCache;
 /**
 * @param {string} url
 * @returns {any}
 */
   getHeaders(url: string): any;
 /**
 * @param {string} url
-* @param {string | undefined} maybe_checksum
-* @param {boolean} allow_global_to_local_copy
+* @param {string | undefined} [maybe_checksum]
 * @returns {any}
 */
-  getFileBytes(url: string, maybe_checksum: string | undefined, allow_global_to_local_copy: boolean): any;
+  get(url: string, maybe_checksum?: string): any;
 /**
 * @param {string} url
 * @param {any} headers