jaredwray · jaredwray · Jul 31, 2025 · Jul 30, 2025 · Jul 30, 2025 · Jul 30, 2025
diff --git a/.github/workflows/codecov.yml b/.github/workflows/codecov.yml
@@ -51,4 +51,5 @@ jobs:
            ./packages/flat-cache/coverage/lcov.info, \
            ./packages/node-cache/coverage/lcov.info, \
            ./packages/memoize/coverage/lcov.info, \
+           ./packages/memory/coverage/lcov.info, \
            ./packages/utils/coverage/lcov.info
diff --git a/packages/benchmark/memory-lru.ts b/packages/benchmark/memory-lru.ts
@@ -1,5 +1,5 @@
 import { createBenchmark, getModuleName, printToConsole, generateAlphaNumeric } from "index.js";
-import { CacheableMemory } from "cacheable";
+import { CacheableMemory } from "@cacheable/memory";
 import QuickLRU from 'quick-lru';
 import { createLRU } from 'lru.min';
 

diff --git a/packages/benchmark/memory.ts b/packages/benchmark/memory.ts
@@ -1,13 +1,13 @@
 import { createBenchmark, getModuleName, printToConsole, generateAlphaNumeric } from "index.js";
-import { CacheableMemory } from "cacheable";
+import { CacheableMemory } from "@cacheable/memory";
 import NodeCache from 'node-cache';
 import { BentoCache, bentostore } from 'bentocache';
 import { memoryDriver } from 'bentocache/drivers/memory';
 
 const bench = createBenchmark("Memory Benchmark", 100000);
 
 // Cacheable Memory
-const cacheable = new CacheableMemory();
+const cacheable = new CacheableMemory({storeHashSize: 1});
 let cacheableName = getModuleName("Cacheable Memory", "1.10.0");
 
 // Node Cache

diff --git a/packages/benchmark/package.json b/packages/benchmark/package.json
@@ -45,6 +45,7 @@
 		"bentocache": "^1.4.0",
 		"cache-manager": "workspace:^",
 		"cacheable": "workspace:^",
+		"@cacheable/memory": "workspace:^",
 		"lru.min": "^1.1.2",
 		"quick-lru": "^7.0.1",
 		"tinybench": "^4.0.1"

diff --git a/packages/memoize/package.json b/packages/memoize/package.json
@@ -34,7 +34,6 @@
 		"@types/eslint": "^9.6.1",
 		"@types/node": "^24.1.0",
 		"@vitest/coverage-v8": "^3.2.4",
-		"cacheable": "workspace:^",
 		"lru-cache": "^11.1.0",
 		"rimraf": "^6.0.1",
 		"tsup": "^8.5.0",

diff --git a/packages/memoize/src/index.ts b/packages/memoize/src/index.ts
@@ -1,5 +1,20 @@
 import {hash, coalesceAsync} from '@cacheable/utils';
-import type {Cacheable, CacheableMemory} from 'cacheable';
+
+export type CacheInstance = {
+	get: (key: string) => Promise<any | undefined>;
+	has: (key: string) => Promise<boolean>;
+	set: (key: string, value: any, ttl?: number | string) => Promise<void>;
+	on: (event: string, listener: (...args: any[]) => void) => void;
+	emit: (event: string, ...args: any[]) => boolean;
+};
+
+export type CacheSyncInstance = {
+	get: (key: string) => any | undefined;
+	has: (key: string) => boolean;
+	set: (key: string, value: any, ttl?: number | string) => void;
+	on: (event: string, listener: (...args: any[]) => void) => void;
+	emit: (event: string, ...args: any[]) => boolean;
+};
 
 export type GetOrSetKey = string | ((options?: GetOrSetOptions) => string);
 
@@ -11,7 +26,7 @@ export type GetOrSetFunctionOptions = {
 
 export type GetOrSetOptions = GetOrSetFunctionOptions & {
 	cacheId?: string;
-	cache: Cacheable;
+	cache: CacheInstance;
 };
 
 export type CreateWrapKey = (function_: AnyFunction, arguments_: any[], options?: WrapFunctionOptions) => string;
@@ -25,11 +40,11 @@ export type WrapFunctionOptions = {
 };
 
 export type WrapOptions = WrapFunctionOptions & {
-	cache: Cacheable;
+	cache: CacheInstance;
 };
 
 export type WrapSyncOptions = WrapFunctionOptions & {
-	cache: CacheableMemory;
+	cache: CacheSyncInstance;
 };
 
 export type AnyFunction = (...arguments_: any[]) => any;
@@ -43,12 +58,12 @@ export function wrapSync<T>(function_: AnyFunction, options: WrapSyncOptions): A
 			cacheKey = options.createKey(function_, arguments_, options);
 		}
 
-		let value = cache.get(cacheKey);
+		let value = cache.get(cacheKey) as T | undefined;
 
 		if (value === undefined) {
 			try {
 				// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-				value = function_(...arguments_);
+				value = function_(...arguments_) as T;
 				cache.set(cacheKey, value, ttl);
 			} catch (error) {
 				cache.emit('error', error);
@@ -101,7 +116,7 @@ export function wrap<T>(function_: AnyFunction, options: WrapOptions): AnyFuncti
 		}
 
 		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-return
-		return cache.getOrSet(cacheKey, async (): Promise<T | undefined> => function_(...arguments_), options);
+		return getOrSet(cacheKey, async (): Promise<T | undefined> => function_(...arguments_), options);
 	};
 }
 

diff --git a/packages/memoize/test/get-or-set.test.ts b/packages/memoize/test/get-or-set.test.ts
@@ -1,12 +1,12 @@
 import {
 	describe, test, expect, vi,
 } from 'vitest';
-import {Cacheable} from 'cacheable';
 import {getOrSet, type GetOrSetOptions} from '../src/index.js';
+import {MockCacheable, MockCacheableMemory} from './mock-cacheable.js';
 
 describe('cacheable get or set', () => {
 	test('should cache results', async () => {
-		const cacheable = new Cacheable();
+		const cacheable = new MockCacheable();
 		const function_ = vi.fn(async () => 1 + 2);
 		const result = await getOrSet('one_plus_two', function_, {cache: cacheable});
 		await getOrSet('one_plus_two', function_, {cache: cacheable});
@@ -15,7 +15,7 @@ describe('cacheable get or set', () => {
 	});
 
 	test('should prevent stampede', async () => {
-		const cacheable = new Cacheable();
+		const cacheable = new MockCacheable();
 		const function_ = vi.fn(async () => 42);
 		await Promise.all([
 			getOrSet('key1', function_, {cache: cacheable}),
@@ -27,7 +27,7 @@ describe('cacheable get or set', () => {
 	});
 
 	test('should throw on getOrSet error', async () => {
-		const cacheable = new Cacheable();
+		const cacheable = new MockCacheable();
 		const function_ = vi.fn(async () => {
 			throw new Error('Test error');
 		});
@@ -37,7 +37,7 @@ describe('cacheable get or set', () => {
 	});
 
 	test('should throw on getOrSet error with cache errors true', async () => {
-		const cacheable = new Cacheable();
+		const cacheable = new MockCacheable();
 		const function_ = vi.fn(async () => {
 			throw new Error('Test error');
 		});
@@ -47,7 +47,7 @@ describe('cacheable get or set', () => {
 	});
 
 	test('should generate key via function on getOrSet', async () => {
-		const cacheable = new Cacheable();
+		const cacheable = new MockCacheable();
 		const generateKey = (options?: GetOrSetOptions) => `custom_key_${options?.cacheId}`;
 		const function_ = vi.fn(async () => Math.random() * 100);
 		const result1 = await getOrSet(generateKey, function_, {cache: cacheable});

diff --git a/packages/memoize/test/mock-cacheable.ts b/packages/memoize/test/mock-cacheable.ts
@@ -0,0 +1,95 @@
+import {type CacheableStoreItem} from '@cacheable/utils';
+import {type CacheInstance, type CacheSyncInstance} from '../src/index.js';
+
+export class MockCacheable implements CacheInstance {
+	private readonly cache = new Map<string, CacheableStoreItem>();
+	private readonly listeners: Record<string, Array<(...args: any[]) => void>> = {};
+
+	async get(key: string): Promise<any | undefined> {
+		const item = this.cache.get(key);
+		if (item?.expires && Date.now() > item.expires) {
+			this.cache.delete(key);
+			return undefined;
+		}
+
+		return item?.value;
+	}
+
+	async has(key: string): Promise<boolean> {
+		return await this.get(key) !== undefined;
+	}
+
+	async set(key: string, value: any, ttl?: number | string): Promise<void> {
+		let expires: number | undefined;
+		if (ttl && typeof ttl === 'number' && ttl > 0) {
+			expires = Date.now() + ttl;
+		}
+
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+		this.cache.set(key, {key, value, expires});
+	}
+
+	on(event: string, listener: (...args: any[]) => void): void {
+		this.listeners[event] ||= [];
+
+		this.listeners[event].push(listener);
+	}
+
+	emit(event: string, ...args: any[]): boolean {
+		const listeners = this.listeners[event];
+		if (listeners) {
+			for (const listener of listeners) {
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+				listener(...args);
+			}
+		}
+
+		return true;
+	}
+}
+
+export class MockCacheableMemory implements CacheSyncInstance {
+	private readonly cache = new Map<string, CacheableStoreItem>();
+	private readonly listeners: Record<string, Array<(...args: any[]) => void>> = {};
+
+	get(key: string): any | undefined {
+		const result = this.cache.get(key);
+		if (result?.expires && Date.now() > result.expires) {
+			this.cache.delete(key);
+			return undefined;
+		}
+
+		return result?.value;
+	}
+
+	has(key: string): boolean {
+		return this.get(key) !== undefined;
+	}
+
+	set(key: string, value: any, ttl?: number | string): void {
+		let expires: number | undefined;
+		if (ttl && typeof ttl === 'number' && ttl > 0) {
+			expires = Date.now() + ttl;
+		}
+
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+		this.cache.set(key, {key, value, expires});
+	}
+
+	on(event: string, listener: (...args: any[]) => void): void {
+		this.listeners[event] ||= [];
+		this.listeners[event].push(listener);
+	}
+
+	emit(event: string, ...args: any[]): boolean {
+		const listeners = this.listeners[event];
+		if (listeners) {
+			for (const listener of listeners) {
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+				listener(...args);
+			}
+		}
+
+		return true;
+	}
+}