@adobe/data 0.1.3 → 0.2.1

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

@@ -0,0 +1,61 @@
+/*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

@@ -0,0 +1,183 @@
+/*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));
+    },
+  };
+}

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

@@ -0,0 +1,81 @@
+/*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 { createExpiringDataCache } from "./expiring-data-cache.js"; // Adjust the import path as necessary
+import { describe, expect, it } from "vitest";
+import { createDataCache } from "./data-cache.js";
+import { getManagedPersistentCache } from "./get-persistent-cache.js";
+
+describe("ExpiringDataCache", () => {
+  it("should store and retrieve an item before it expires", async () => {
+    const time = Date.now();
+    let timePassed = 0;
+    const getTime = () => time + timePassed;
+    const cache = createExpiringDataCache<string, string>(
+      createDataCache(
+        await getManagedPersistentCache("expiring-data-cache-test", {
+          maximumMemoryEntries: 10,
+          maximumStorageEntries: 100,
+        })
+      ),
+      getTime
+    );
+
+    cache.put("key1", "value1", { maximumDuration: 1000 }); // Expires in 1000ms
+    expect(await cache.match("key1")).toBe("value1");
+
+    timePassed = 500;
+    expect(await cache.match("key1")).toBe("value1");
+
+    timePassed = 999;
+    expect(await cache.match("key1")).toBe("value1");
+
+    timePassed = 1000;
+    expect(await cache.match("key1")).toBeUndefined();
+
+    timePassed = 1001;
+    expect(await cache.match("key1")).toBeUndefined();
+
+    timePassed = 2000;
+    expect(await cache.match("key1")).toBeUndefined();
+  });
+
+  it("should immediately expire items when maximumDuration is 0", async () => {
+    const time = Date.now();
+    let timePassed = 0;
+    const getTime = () => time + timePassed;
+    const cache = createExpiringDataCache<string, string>(
+      createDataCache(
+        await getManagedPersistentCache("expiring-data-cache-test", {
+          maximumMemoryEntries: 10,
+          maximumStorageEntries: 100,
+        })
+      ),
+      getTime
+    );
+
+    cache.put("key1", "value1", { maximumDuration: 0 }); // Expires immediately
+    expect(await cache.match("key1")).toBeUndefined();
+
+    timePassed = 1000;
+    expect(await cache.match("key1")).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,61 @@
+/*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 Data } from "../data.js";
+import { type DataCache, DataCacheInternal } from "./data-cache.js";
+
+type ExpiringData<T extends Data> = {
+  expiration: number | null;
+  value: T;
+};
+
+/**
+ * Creates a new expiring data cache with the specified underlying cache.
+ */
+export function createExpiringDataCache<K extends Data, V extends Data>(
+  baseCache: DataCacheInternal<K, V>,
+  getTime = () => Date.now()
+): DataCache<K, V> {
+  const cache = baseCache as unknown as DataCacheInternal<K, ExpiringData<V>>;
+  return {
+    async match(key: K): Promise<V | undefined> {
+      const entry = await cache.match(key);
+      if (!entry) {
+        return undefined;
+      }
+      if (entry.expiration != null && entry.expiration <= getTime()) {
+        await cache.delete(key);
+        return undefined;
+      }
+      return entry.value;
+    },
+    async put(key: K, value: V, options): Promise<void> {
+      const { maximumDuration: maxDuration } = options || {};
+      const expiration =
+        (maxDuration !== undefined) && maxDuration >= 0 ? getTime() + maxDuration : null;
+      await cache.put(key, { value, expiration });
+    },
+    async delete(key: K): Promise<void> {
+      await cache.delete(key);
+    },
+  };
+}

package/src/cache/fallback-async-cache.ts

@@ -0,0 +1,49 @@
+/*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";
+
+/**
+ * Provides a combined cache interface.
+ * Writes to both caches.
+ * Prefers to read from the faster cache first before falling back to slower.
+ */
+export function createFallbackAsyncCache(
+  fasterSmaller: AsyncCache<Request, Response>,
+  slowerLarger: AsyncCache<Request, Response>
+): AsyncCache<Request, Response> {
+  return {
+    async put(key: Request, value: Response): Promise<void> {
+      await Promise.all([
+        fasterSmaller.put(key, value),
+        slowerLarger.put(key, value),
+      ]);
+    },
+    async match(key: Request): Promise<Response | undefined> {
+      return (
+        (await fasterSmaller.match(key)) ?? (await slowerLarger.match(key))
+      );
+    },
+    async delete(key: Request): Promise<void> {
+      await Promise.all([fasterSmaller.delete(key), slowerLarger.delete(key)]);
+    },
+  };
+}

package/src/cache/functions/async-data-function.ts

@@ -0,0 +1,25 @@
+/*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.*/
+
+export type AsyncDataFunction<InputArgs extends Array<unknown>, Output> = (
+  ...args: InputArgs
+) => Promise<Output>;

package/src/cache/functions/functions.test.ts

@@ -0,0 +1,84 @@
+/*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 { memoize } from "./memoize.js";
+import { preventParallelExecution } from "./prevent-parallel-execution.js";
+import { describe, expect, it } from "vitest";
+
+describe("Function", () => {
+  describe("prevent parallel execution", () => {
+    it("should block parallel execution and return same promise", async () => {
+      let addCallCount = 0;
+      async function add(a: number, b: number): Promise<number> {
+        addCallCount++;
+        return new Promise((resolve) => {
+          setTimeout(() => {
+            resolve(a + b);
+          }, 100);
+        });
+      }
+
+      async function testAddBlocksParallelExecution(addFn: typeof add) {
+        addCallCount = 0;
+        const promises = [addFn(1, 2), addFn(1, 2), addFn(1, 2)];
+        const results = await Promise.all(promises);
+        expect(results).toEqual([3, 3, 3]);
+      }
+
+      const addFn = preventParallelExecution(add);
+      await testAddBlocksParallelExecution(addFn);
+      // after all have completed... then another can execute
+      addCallCount = 0;
+      expect(await addFn(1, 2)).toEqual(3);
+      expect(addCallCount).toEqual(1);
+    });
+  });
+
+  describe("memoize", () => {
+    it("should block parallel execution and return same promise", async () => {
+      let addCallCount = 0;
+      async function add(a: number, b: number): Promise<number> {
+        addCallCount++;
+        return new Promise((resolve) => {
+          setTimeout(() => {
+            resolve(a + b);
+          }, 100);
+        });
+      }
+
+      async function testAddBlocksParallelExecution(addFn: typeof add) {
+        addCallCount = 0;
+        const promises = [addFn(1, 2), addFn(1, 2), addFn(1, 2)];
+        const results = await Promise.all(promises);
+        expect(results).toEqual([3, 3, 3]);
+      }
+
+      //  now memoize the addFn and verify that it is cached.
+      const addFn = memoize("addFn-v1", add);
+      await testAddBlocksParallelExecution(addFn);
+      // after all have completed... then another can execute
+      addCallCount = 0;
+      expect(await addFn(1, 2)).toEqual(3);
+      // with memoize, the count should be 0 because we get a cached result.
+      expect(addCallCount).toEqual(0);
+    });
+  });
+});

package/{cache/functions/get-cached.test.js → src/cache/functions/get-cached.test.ts}

@@ -19,78 +19,95 @@ 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 { getCached } from "./get-cached.js";
 import { describe, expect, it } from "vitest";
+
 describe("getCached", () => {
     it("should cache values on objects", () => {
         const obj = { id: 1 };
         let factoryCallCount = 0;
-        const factory = (o) => {
+
+        const factory = (o: typeof obj) => {
             factoryCallCount++;
             return { computed: o.id * 2 };
         };
+
         // First call should invoke factory
         const result1 = getCached(obj, factory);
         expect(result1).toEqual({ computed: 2 });
         expect(factoryCallCount).toBe(1);
+
         // Second call should use cached value
         const result2 = getCached(obj, factory);
         expect(result2).toEqual({ computed: 2 });
         expect(factoryCallCount).toBe(1);
     });
+
     it("should cache different values for different objects", () => {
         const obj1 = { id: 1 };
         const obj2 = { id: 2 };
         let factoryCallCount = 0;
-        const factory = (o) => {
+
+        const factory = (o: typeof obj1) => {
             factoryCallCount++;
             return { computed: o.id * 2 };
         };
+
         // Call for first object
         const result1 = getCached(obj1, factory);
         expect(result1).toEqual({ computed: 2 });
         expect(factoryCallCount).toBe(1);
+
         // Call for second object should invoke factory again
         const result2 = getCached(obj2, factory);
         expect(result2).toEqual({ computed: 4 });
         expect(factoryCallCount).toBe(2);
     });
+
     it("should cache different values for different factories on same object", () => {
         const obj = { id: 1 };
         let factory1CallCount = 0;
         let factory2CallCount = 0;
-        const factory1 = (o) => {
+
+        const factory1 = (o: typeof obj) => {
             factory1CallCount++;
             return { computed: o.id * 2 };
         };
-        const factory2 = (o) => {
+
+        const factory2 = (o: typeof obj) => {
             factory2CallCount++;
             return { computed: o.id * 3 };
         };
+
         // Call first factory
         const result1 = getCached(obj, factory1);
         expect(result1).toEqual({ computed: 2 });
         expect(factory1CallCount).toBe(1);
         expect(factory2CallCount).toBe(0);
+
         // Call second factory
         const result2 = getCached(obj, factory2);
         expect(result2).toEqual({ computed: 3 });
         expect(factory1CallCount).toBe(1);
         expect(factory2CallCount).toBe(1);
     });
+
     it("should handle primitive values", () => {
         const obj = { id: 1 };
         let factoryCallCount = 0;
-        const factory = (o) => {
+
+        const factory = (o: typeof obj) => {
             factoryCallCount++;
             return o.id * 2;
         };
+
         const result1 = getCached(obj, factory);
         expect(result1).toBe(2);
         expect(factoryCallCount).toBe(1);
+
         const result2 = getCached(obj, factory);
         expect(result2).toBe(2);
         expect(factoryCallCount).toBe(1);
     });
-});
-//# sourceMappingURL=get-cached.test.js.map
+});