remove caching from WrappedStore

Author: frasercl

src/loaders/zarr_utils/CachingArray.ts

@@ -1,6 +1,7 @@
 import { Array, ArrayMetadata, Chunk, DataType } from "@zarrita/core";
 import VolumeCache, { CacheData } from "../../VolumeCache";
 import { AbsolutePath, Readable } from "@zarrita/storage";
+import { pathIsToMetadata } from "./utils";
 
 const ZARR_EXTS = [".zarray", ".zgroup", ".zattrs", "zarr.json"];
 
@@ -12,7 +13,7 @@ export default class CachingArray<T extends DataType, Store extends Readable = R
   }
 
   async getChunk(coords: number[], opts?: Parameters<Store["get"]>[1]): Promise<Chunk<T>> {
-    if (!this.cache || ZARR_EXTS.some((s) => this.path.endsWith(s))) {
+    if (!this.cache || pathIsToMetadata(this.path)) {
       return super.getChunk(coords, opts);
     }
 

src/loaders/zarr_utils/WrappedStore.ts

@@ -2,9 +2,9 @@ import { FetchStore } from "zarrita";
 import { AbsolutePath, AsyncMutable, Readable } from "@zarrita/storage";
 
 import SubscribableRequestQueue from "../../utils/SubscribableRequestQueue";
-import VolumeCache from "../../VolumeCache";
 
 import { SubscriberId } from "./types";
+import { pathIsToMetadata } from "./utils";
 
 type WrappedStoreOpts<Opts> = {
   options?: Opts;
@@ -15,26 +15,17 @@ type WrappedStoreOpts<Opts> = {
 
 /**
  * `Readable` is zarrita's minimal abstraction for any source of data.
- * `WrappedStore` wraps another `Readable` and adds (optional) connections to `VolumeCache` and `RequestQueue`.
+ * `WrappedStore` wraps another `Readable` and adds useful extras, notably an (optional) connection to `RequestQueue`
  */
 class WrappedStore<Opts, S extends Readable<Opts> = Readable<Opts>> implements AsyncMutable<WrappedStoreOpts<Opts>> {
-  constructor(private baseStore: S, private cache?: VolumeCache, private queue?: SubscribableRequestQueue) {}
+  constructor(private baseStore: S, private queue?: SubscribableRequestQueue) {}
   // Dummy implementation to make this class easier to use in tests
   set(_key: AbsolutePath, _value: Uint8Array): Promise<void> {
     return Promise.resolve();
   }
 
-  private async getAndCache(key: AbsolutePath, cacheKey: string, opts?: Opts): Promise<Uint8Array | undefined> {
-    const result = await this.baseStore.get(key, opts);
-    if (this.cache && result) {
-      this.cache.insert(cacheKey, result);
-    }
-    return result;
-  }
-
   async get(key: AbsolutePath, opts?: WrappedStoreOpts<Opts> | undefined): Promise<Uint8Array | undefined> {
-    const ZARR_EXTS = [".zarray", ".zgroup", ".zattrs", "zarr.json"];
-    if (!this.cache || ZARR_EXTS.some((s) => key.endsWith(s))) {
+    if (pathIsToMetadata(key)) {
       return this.baseStore.get(key, opts?.options);
     }
     if (opts?.reportKey) {
@@ -48,23 +39,17 @@ class WrappedStore<Opts, S extends Readable<Opts> = Readable<Opts>> implements A
 
     const fullKey = keyPrefix + key.slice(1);
 
-    // Check the cache
-    const cacheResult = this.cache.get(fullKey);
-    if (cacheResult) {
-      return new Uint8Array(cacheResult);
-    }
-
     // Not in cache; load the chunk and cache it
     if (this.queue && opts) {
       return this.queue.addRequest(
         fullKey,
         opts.subscriber,
-        () => this.getAndCache(key, fullKey, opts?.options),
+        async () => this.baseStore.get(key, opts?.options),
         opts.isPrefetch
       );
     } else {
       // Should we ever hit this code?  We should always have a request queue.
-      return this.getAndCache(key, fullKey, opts?.options);
+      return this.baseStore.get(key, opts?.options);
     }
   }
 }

src/loaders/zarr_utils/utils.ts

@@ -18,6 +18,9 @@ export function getSourceChannelNames(src: ZarrSource): string[] {
   return Array.from({ length }, (_, idx) => `Channel ${idx + src.channelOffset}`);
 }
 
+const META_FILENAMES = [".zarray", ".zgroup", ".zattrs", "zarr.json"];
+export const pathIsToMetadata = (path: string): boolean => META_FILENAMES.some((s) => path.endsWith(s));
+
 /** Turns `axesTCZYX` into the number of dimensions in the array */
 export const getDimensionCount = ([t, c, z]: TCZYX<number>) => 2 + Number(t > -1) + Number(c > -1) + Number(z > -1);