@adobe/data 0.2.1 → 0.2.3

package/src/cache/blob-store.test.ts

@@ -1,176 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { type BlobStore, createBlobStore } from "./blob-store.js";
-
-describe("blobStore", () => {
-    // Mock URL.createObjectURL and URL.revokeObjectURL
-    const mockCreateObjectURL = vi.fn((blob: Blob) => `blob:${Math.random()}`);
-    const mockRevokeObjectURL = vi.fn();
-    let testBlobStore: BlobStore;
-    let createdUrl: string;
-
-    beforeEach(async () => {
-        // Setup URL mock functions
-        const originalCreateObjectURL = URL.createObjectURL;
-        const originalRevokeObjectURL = URL.revokeObjectURL;
-
-        // Ensure we create a non-http URL
-        mockCreateObjectURL.mockImplementation((blob: Blob) => {
-            createdUrl = `blob:${Math.random()}`;
-            return createdUrl;
-        });
-
-        URL.createObjectURL = mockCreateObjectURL;
-        URL.revokeObjectURL = mockRevokeObjectURL;
-
-        // Clear mock call history
-        mockCreateObjectURL.mockClear();
-        mockRevokeObjectURL.mockClear();
-
-        testBlobStore = await createBlobStore();
-
-        return () => {
-            URL.createObjectURL = originalCreateObjectURL;
-            URL.revokeObjectURL = originalRevokeObjectURL;
-        };
-    });
-
-    afterEach(() => {
-        // Clean up any remaining borrowed URLs
-        mockCreateObjectURL.mockReset();
-        mockRevokeObjectURL.mockReset();
-    });
-
-    describe("URL reference counting", () => {
-        it("should reuse the same URL for multiple borrows of the same blob", async () => {
-            // Create a test blob
-            const testBlob = new Blob(["test"], { type: "text/plain" });
-            const blobRef = await testBlobStore.getRef(testBlob);
-
-            // Borrow the URL multiple times
-            const url1 = await testBlobStore.borrowUrl(blobRef);
-            const url2 = await testBlobStore.borrowUrl(blobRef);
-            const url3 = await testBlobStore.borrowUrl(blobRef);
-
-            expect(url1).toBeTruthy();
-            expect(url1).toBe(url2);
-            expect(url2).toBe(url3);
-            expect(url1).toMatch(/^blob:/); // Verify it's a blob URL
-
-            // createObjectURL should only be called once
-            expect(mockCreateObjectURL).toHaveBeenCalledTimes(1);
-
-            // Clean up
-            testBlobStore.returnUrl(url1);
-            testBlobStore.returnUrl(url2);
-            testBlobStore.returnUrl(url3);
-        });
-
-        it("should only revoke URL when all references are returned", async () => {
-            const testBlob = new Blob(["test"], { type: "text/plain" });
-            const blobRef = await testBlobStore.getRef(testBlob);
-
-            // Borrow the URL three times
-            const url1 = await testBlobStore.borrowUrl(blobRef);
-            const url2 = await testBlobStore.borrowUrl(blobRef);
-            const url3 = await testBlobStore.borrowUrl(blobRef);
-
-            expect(url1).toMatch(/^blob:/); // Verify it's a blob URL
-
-            // Return URLs one by one
-            testBlobStore.returnUrl(url1);
-            expect(mockRevokeObjectURL).not.toHaveBeenCalled();
-
-            testBlobStore.returnUrl(url2);
-            expect(mockRevokeObjectURL).not.toHaveBeenCalled();
-
-            testBlobStore.returnUrl(url3);
-            expect(mockRevokeObjectURL).toHaveBeenCalledTimes(1);
-            expect(mockRevokeObjectURL).toHaveBeenCalledWith(createdUrl);
-        });
-
-        it("should handle remote URLs correctly", async () => {
-            const remoteRef = testBlobStore.createRemoteBlobRef("http://example.com/image.jpg");
-
-            // Borrow remote URL multiple times
-            const url1 = await testBlobStore.borrowUrl(remoteRef);
-            const url2 = await testBlobStore.borrowUrl(remoteRef);
-
-            expect(url1).toBe("http://example.com/image.jpg");
-            expect(url2).toBe("http://example.com/image.jpg");
-            expect(mockCreateObjectURL).not.toHaveBeenCalled();
-
-            // Return URLs
-            testBlobStore.returnUrl(url1);
-            testBlobStore.returnUrl(url2);
-
-            // Should not revoke remote URLs
-            expect(mockRevokeObjectURL).not.toHaveBeenCalled();
-        });
-
-        it("should handle null inputs gracefully", async () => {
-            const nullUrl = await testBlobStore.borrowUrl(null);
-            expect(nullUrl).toBeNull();
-
-            // Should not throw when returning null
-            expect(() => testBlobStore.returnUrl(null)).not.toThrow();
-        });
-
-        it('demonstrates race condition in borrowUrl', async () => {
-            const store = testBlobStore;
-            const testBlob = new Blob(['test data'], { type: 'text/plain' });
-            const blobRef = await store.getRef(testBlob);
-
-            // Create an artificially delayed getBlob to simulate network latency
-            const originalGetBlob = store.getBlob;
-            store.getBlob = async (ref) => {
-                await new Promise(resolve => setTimeout(resolve, 50)); // Add delay
-                return originalGetBlob(ref);
-            };
-
-            // Make two parallel borrowUrl calls
-            const [url1, url2] = await Promise.all([
-                store.borrowUrl(blobRef),
-                store.borrowUrl(blobRef)
-            ]);
-
-            expect(url1).toBe(url2); // Same URL should be returned
-
-            // Return one of the URLs
-            store.returnUrl(url1);
-
-            // Verify that the borrow count is still 1 since we borrowed twice and returned once
-            expect(store._testGetBorrowCount(blobRef)).toBe(1);
-
-            // Return the second URL
-            store.returnUrl(url2);
-
-            // Verify the borrow count is now 0
-            expect(store._testGetBorrowCount(blobRef)).toBe(0);
-
-            // Verify the URL was revoked
-            expect(mockRevokeObjectURL).toHaveBeenCalledTimes(1);
-            expect(mockRevokeObjectURL).toHaveBeenCalledWith(url1);
-        });
-    });
-}); 

package/src/cache/blob-store.ts

@@ -1,278 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { getManagedPersistentCache } from "./get-persistent-cache.js";
-import { type FromSchema, type Schema } from "../schema/index.js";
-import { blobToHash } from "./functions/hashing/blob-to-hash.js";
-import { preventParallelExecution } from "./functions/prevent-parallel-execution.js";
-
-const remoteUrlPrefix = "http";
-const RemoteUrlSchema = {
-  type: "string",
-  pattern: `${remoteUrlPrefix}.*`,
-} as const satisfies Schema;
-type RemoteUrl = `${typeof remoteUrlPrefix}${string}`;
-
-const RemoteBlobRefSchema = {
-  required: ["remoteBlobRef"],
-  properties: {
-    remoteBlobRef: RemoteUrlSchema,
-  },
-  additionalProperties: false,
-} as const satisfies Schema;
-type RemoteBlobRef = FromSchema<typeof RemoteBlobRefSchema>;
-
-const LocalBlobRefSchema = {
-  required: ["localBlobRef"],
-  properties: {
-    localBlobRef: { type: "string" },
-  },
-  additionalProperties: false,
-} as const satisfies Schema;
-type LocalBlobRef = FromSchema<typeof LocalBlobRefSchema>;
-
-export const BlobRefSchema = {
-  oneOf: [RemoteBlobRefSchema, LocalBlobRefSchema],
-} as const satisfies Schema;
-
-/**
- * Represents a reference to a blob as a plain JSON object.
- * Do NOT create this type directly.
- * Use the BlobStore to create and manage blob references.
- */
-export type BlobRef = FromSchema<typeof BlobRefSchema>;
-
-function isRemoteBlobRef(ref: unknown): ref is RemoteBlobRef {
-  const maybe = ref as Partial<RemoteBlobRef> | undefined;
-  return typeof maybe?.remoteBlobRef === "string";
-}
-
-function isLocalBlobRef(ref: unknown): ref is LocalBlobRef {
-  const maybe = ref as Partial<LocalBlobRef> | undefined;
-  return typeof maybe?.localBlobRef === "string";
-}
-
-export function isBlobRef(value: unknown): value is BlobRef {
-  return isRemoteBlobRef(value) || isLocalBlobRef(value);
-}
-
-function isRemoteUrl(url: string): url is RemoteUrl {
-  return url.startsWith(remoteUrlPrefix);
-}
-
-function toRequest(ref: LocalBlobRef) {
-  return new Request(`${window.location.origin}/${ref.localBlobRef}`);
-}
-
-/**
- * Defined as a symbol because we only want it used by internal code like DataCache.
- */
-export const hasBlobInternalDoNotUse = Symbol("hasBlob");
-
-/**
- * A blob store is a service that can efficiently store blobs across sessions and retrieve them using the browsers Cache api.
- */
-export interface BlobStore {
-  /**
-   * Stores a blob and returns a reference to it.
-   * Blob references are based upon the content and type of the Blob.
-   * If an equivalent blob is stored, an equivalent reference will be returned every time.
-   */
-  getRef(b: Blob | string): Promise<BlobRef>;
-  /**
-   * Gets a blob from the blob store or null if it is not available.
-   */
-  getBlob(r: BlobRef | null): Promise<Blob | null>;
-  /**
-   * Checks if the blob is still available.
-   */
-  hasBlob(r: BlobRef | null): Promise<boolean>;
-  /**
-   * Do NOT use this directly, use useBorrowUrl hook instead as it will automatically return the url when the component unmounts.
-   */
-  borrowUrl(r: BlobRef | null): Promise<string | null>;
-  /**
-   * Return a url that was previously borrowed from borrowUrl.
-   * Failure to do so may result in memory leaking.
-   * @param url The url provided by borrowUrl.
-   */
-  returnUrl(url: string | null): void;
-  /**
-   * Removes a blob from the store.
-   */
-  releaseBlob(r: BlobRef): Promise<void>;
-  /**
-   * Creates a new remote blob ref. The url must start with http.
-   * This should only be called if the remote content is persistent and immutable.
-   */
-  createRemoteBlobRef(url: string): BlobRef;
-  /**
-   * TEST ONLY: Gets the current borrow count for a blob reference.
-   * This should only be used in tests to verify reference counting behavior.
-   * @param r The blob reference to check
-   * @returns The number of times the blob reference has been borrowed, or 0 if not borrowed
-   */
-  _testGetBorrowCount(r: BlobRef): number;
-}
-
-/**
- * Creates a new blob store instance.
- */
-export function createBlobStore() {
-  const cachePromise = getManagedPersistentCache("blobstore", {
-    maximumMemoryEntries: 10,
-    maximumStorageEntries: 1000,
-  });
-
-  // Track borrowed URLs and their reference counts
-  const borrowedUrls = new Map<string, { url: string; count: number }>();
-  // Reverse mapping for O(1) lookup
-  const urlToKey = new Map<string, string>();
-
-  async function getRef(blob: Blob | string): Promise<BlobRef> {
-    const cache = await cachePromise;
-    if (typeof blob === "string") {
-      //  if this is not a remote url, then we can assume it is a data url and fetch the blob from it.
-      blob = await (await fetch(blob)).blob();
-    }
-    const ref = {
-      localBlobRef: await blobToHash(blob),
-    } as const satisfies LocalBlobRef;
-
-    const request = toRequest(ref);
-    const response = new Response(blob);
-
-    await cache.put(request, response);
-    return ref;
-  }
-
-  async function hasBlob(r: BlobRef): Promise<boolean> {
-    if (isRemoteBlobRef(r)) {
-      return true;
-    }
-    const cache = await cachePromise;
-    const response = await cache.match(toRequest(r));
-    return response !== undefined;
-  }
-
-  async function getBlob(r?: BlobRef | null): Promise<Blob | null> {
-    if (!r) {
-      return null;
-    }
-    const response = await (isRemoteBlobRef(r)
-      ? fetch(r.remoteBlobRef)
-      : (await cachePromise).match(toRequest(r)));
-    if (!response) {
-      return null;
-    }
-    if (!response.ok) {
-      // this should only happen with remote urls. local blob responses are always ok.
-      throw new Error(response.statusText);
-    }
-    return response.blob();
-  }
-
-  async function releaseBlob(r: BlobRef): Promise<void> {
-    if (isLocalBlobRef(r)) {
-      const cache = await cachePromise;
-      cache.delete(toRequest(r));
-    }
-  }
-
-  /**
-   * prevent parallel execution to avoid race condition in borrowUrl while awaiting getBlob
-   */
-  const borrowUrlInternalNoIncrement = preventParallelExecution(async (key: string, r: BlobRef): Promise<{ url: string; count: number } | null> => {
-    if (isRemoteBlobRef(r)) {
-      return { url: r.remoteBlobRef, count: 0 };
-    }
-    const blob = await getBlob(r);
-    if (!blob) {
-      return null;
-    }
-    const url = URL.createObjectURL(blob);
-    const existing = { url, count: 0 };
-    borrowedUrls.set(key, existing);
-    urlToKey.set(url, key);
-    return existing;
-  });
-
-  async function borrowUrl(r: BlobRef): Promise<string | null> {
-    const key = JSON.stringify(r);
-    const existing = borrowedUrls.get(key) ?? await borrowUrlInternalNoIncrement(key, r);
-    if (!existing) {
-      return null;
-    }
-    existing.count++;
-    return existing.url;
-  }
-
-  function returnUrl(url: string | null) {
-    if (!url) {
-      return;
-    }
-
-    const key = urlToKey.get(url);
-    if (key) {
-      const entry = borrowedUrls.get(key)!;
-      if (entry) {
-        entry.count--;
-        if (entry.count <= 0) {
-          borrowedUrls.delete(key);
-          urlToKey.delete(url);
-          if (!isRemoteUrl(url)) {
-            URL.revokeObjectURL(url);
-          }
-        }
-      }
-    }
-  }
-
-  function createRemoteBlobRef(url: string): BlobRef {
-    if (!isRemoteUrl(url)) {
-      throw new Error(
-        `Invalid url, expected to start with (${remoteUrlPrefix}): ${url}`
-      );
-    }
-    return { remoteBlobRef: url } satisfies RemoteBlobRef;
-  }
-
-  function _testGetBorrowCount(r: BlobRef): number {
-    const key = JSON.stringify(r);
-    return borrowedUrls.get(key)?.count ?? 0;
-  }
-
-  return {
-    getRef,
-    getBlob,
-    hasBlob,
-    borrowUrl,
-    returnUrl,
-    releaseBlob,
-    createRemoteBlobRef,
-    _testGetBorrowCount,
-  } as const satisfies BlobStore;
-}
-
-/**
- * The global blob store that can be used to store and retrieve blobs.
- */
-export const blobStore: BlobStore = createBlobStore();

package/src/cache/data-cache.test.ts

@@ -1,61 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { getDataCache } from "./data-cache.js";
-import { beforeAll, describe, expect, it } from "vitest";
-
-describe("DataCache", () => {
-  beforeAll(() => {});
-  it("should allow storing and retrieving values in namespaced/versioned caches", async () => {
-    //  get a namespaced cache
-    const cache = await getDataCache("test:v1");
-
-    //  create some keys and values to store
-    const key = { foo: 1, bar: [{ baz: 12 }] };
-    const valueIn = { alpha: "bet", bar: ["a", "b"] };
-
-    //  store a key/value pair
-    await cache.put(key, valueIn);
-
-    //  retrieve the value
-    const valueOut = await cache.match(key);
-
-    //  output is NOT identical
-    expect(valueOut !== valueIn).toBe(true);
-
-    //  output IS structurally equal
-    expect(valueOut).toEqual(valueIn);
-
-    //  output from structurally equivalent key is the same
-    expect(await cache.match(JSON.parse(JSON.stringify(key)))).toEqual(valueIn);
-
-    //  output from equivalent cache (constructed with same name/version) is the same.
-    expect(await (await getDataCache("test:v1")).match(key)).toEqual(valueIn);
-
-    //  output from different named cache is undefined
-    expect(await (await getDataCache("test2:v1")).match(key)).toEqual(
-      undefined
-    );
-
-    //  output from different cache version is undefined
-    expect(await (await getDataCache("test:v2")).match(key)).toEqual(undefined);
-  });
-});

package/src/cache/data-cache.ts

@@ -1,183 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { type AsyncCache } from "./async-cache.js";
-import { type BlobRef, BlobStore, isBlobRef, blobStore } from "./blob-store.js";
-import { getManagedPersistentCache } from "./get-persistent-cache.js";
-
-import { type Data } from "../data.js";
-import { createExpiringDataCache } from "./expiring-data-cache.js";
-
-export type DataCacheInternal<K extends Data, V extends Data> = AsyncCache<
-  K,
-  V
->;
-
-/**
- * A persistent cache that stores data with an optional expiration time.
- */
-export interface DataCache<K extends Data, V extends Data> { 
-  /**
-   * Stores a new value within the cache.
-   * @param key key to use to store the value
-   * @param value the value to store
-   * @param maxDuration the time to live relative to the current time
-   */
-  put(key: K, value: V, options?: { maximumDuration: number }): Promise<void>;
-  /**
-   * Attempts to retrieve a value from the cache.
-   * @param key The key previously used to store the value.
-   */
-  match(key: K): Promise<V | undefined>;
-  /**
-   * Deletes an item from the cache.
-   * @param key The key previously used to store the value.
-   */
-  delete(key: K): Promise<void>;
-}
-
-/**
- * Recursively searches arbitrary JSON data and locates any BlobRefs within it.
- */
-function getBlobRefsInternal(
-  d: Data,
-  refs: Array<BlobRef> = []
-): Array<BlobRef> {
-  if (d && typeof d === "object") {
-    if (isBlobRef(d)) {
-      refs.push(d);
-    }
-    for (const value of Array.isArray(d) ? d : Object.values(d)) {
-      getBlobRefsInternal(value, refs);
-    }
-  }
-  return refs;
-}
-
-export function getBlobRefs(d: Data): Array<BlobRef> {
-  return getBlobRefsInternal(d);
-}
-
-function toRequest(data: Data) {
-  return new Request("http://cache.key?" + encodeURI(JSON.stringify(data)));
-}
-
-async function areAllBlobRefsPresentInBlobStore(
-  blobstore: BlobStore,
-  data: Data
-): Promise<boolean> {
-  for (const ref of getBlobRefs(data)) {
-    //  TODO: consider using a batched request to the blobstore or await Promise.all
-    if (!(await blobstore.hasBlob(ref))) {
-      // a contained blob ref is expired, so the entire data structure is expired
-      return false;
-    }
-  }
-  return true;
-}
-
-export function createDataCache<K extends Data, V extends Data>(
-  cache: AsyncCache<Request, Response>
-): DataCacheInternal<K, V> {
-  return {
-    async match(k: K): Promise<V | undefined> {
-      const response = await cache.match(toRequest(k));
-      return response?.json();
-    },
-    async put(k: K, v: V): Promise<void> {
-      const blob = new Blob([JSON.stringify(v)], { type: "application/json" });
-      await cache.put(toRequest(k), new Response(blob));
-    },
-    async delete(k: K): Promise<void> {
-      await cache.delete(toRequest(k));
-    },
-  };
-}
-
-export function createBlobRefAwareDataCache<
-  K extends Data = Data,
-  V extends Data = Data,
->(
-  baseCache: DataCacheInternal<K, V> = dataCache as DataCacheInternal<K, V>,
-  blobstore = blobStore
-): DataCacheInternal<Data, Data> {
-  return {
-    ...baseCache,
-    async match(k: K): Promise<Data | undefined> {
-      const result = await baseCache.match(k);
-      if (
-        result !== undefined &&
-        !(await areAllBlobRefsPresentInBlobStore(blobstore, result))
-      ) {
-        await baseCache.delete(k);
-        return undefined;
-      }
-      return result;
-    },
-  };
-}
-
-const managedPersistentCache = await getManagedPersistentCache("datacache", {
-  maximumMemoryEntries: 100,
-  maximumStorageEntries: 1000,
-});
-const blobRefAwareDataCache = await createBlobRefAwareDataCache(
-  createDataCache(managedPersistentCache)
-);
-export const dataCache: DataCache<Data, Data> = createExpiringDataCache(
-  blobRefAwareDataCache
-);
-
-/**
- * Retrieves a namespaced data cache. Calling it multiple times will return an equivalent cache.
- * Values stored within a data cache generally persist across sessions.
- * @param nameSpace A unique string used to isolate values within this cache from other caches.
- */
-export function getDataCache<K extends Data, V extends Data>(
-  nameSpace: string
-): DataCache<K, V> {
-  return getNamespacedDataCacheInternal(nameSpace, dataCache);
-}
-
-function getNamespacedDataCacheInternal<K extends Data, V extends Data>(
-  name: string,
-  mainCache = dataCache
-): DataCache<K, V> {
-  if (!name || name.length === 0) {
-    throw new Error(`name is required`);
-  }
-
-  const getNSKey = (key: K) => {
-    return { name, key };
-  };
-
-  return {
-    async match(key: K): Promise<V | undefined> {
-      return (await mainCache.match(getNSKey(key))) as V | undefined;
-    },
-    async put(key: K, value: V, options): Promise<void> {
-      await mainCache.put(getNSKey(key), value, options);
-    },
-    async delete(key: K): Promise<void> {
-      await mainCache.delete(getNSKey(key));
-    },
-  };
-}