feat: add husky pre-commit hook and enhance README with ESM note; update test cases for no-argument functions; more robust key generation for helpers

Author: apetta

Diff for: .husky/pre-commit

@@ -0,0 +1 @@
+pnpm check && pnpm test

Diff for: README.md

@@ -2,6 +2,8 @@
 
 `node-cache-plus` is a wrapper around the popular library [`node-cache`](https://github.com/node-cache/node-cache/tree/master) with additional features such as tag-based invalidation, factory functions, and other helpers for in-memory caching in Node.js applications.
 
+Sorry 🦖, this is an ESM-only package.
+
 ## Installation
 
 To install `node-cache-plus`, use your preferred package manager:

Diff for: package.json

@@ -14,9 +14,10 @@
 		"check-exports": "attw --pack . --ignore-rules=cjs-resolves-to-esm",
 		"check": "biome check ./src --diagnostic-level=error --fix",
 		"check-tsc": "tsc --noEmit",
-		"test": "vitest run",
+		"test": "vitest run --printConsoleTrace=true",
 		"ci": "pnpm check && pnpm test && pnpm build && pnpm check-exports",
-		"prepublishOnly": "pnpm run ci"
+		"prepublishOnly": "pnpm run ci",
+		"prepare": "husky"
 	},
 	"keywords": [
 		"cache",
@@ -67,6 +68,7 @@
 		"@biomejs/biome": "1.9.4",
 		"@changesets/cli": "~2.27.10",
 		"@types/node": "~22.10.2",
+		"husky": "~9.1.7",
 		"tsup": "~8.3.5",
 		"typedoc": "~0.27.5",
 		"typescript": "~5.7.2",

Diff for: pnpm-lock.yaml

@@ -3,7 +3,7 @@ import type { Cache } from "./Cache";
 import { getDefaultCache } from "./defaults";
 import type { CacheFunctionOptions } from "./types";
 
-function defaultKeyGenerator(fnName: string, args: any[]): string {
+export function defaultKeyGenerator(fnName: string, args: any[] = []): string {
 	const hash = crypto
 		.createHash("sha1")
 		.update(JSON.stringify(args))
@@ -36,7 +36,7 @@ export async function cachedCall<T, A extends any[]>(
 	} = options;
 
 	const cache = cacheInstance || getDefaultCache();
-	const fnName = fn.name || "anonymous_function";
+	const fnName = `cachedCall_${fn.name || "anonymous_function"}`;
 	const cacheKey = key ?? keyGenerator(fnName, fnArgs);
 
 	const cachedData = cache.get<T>(cacheKey);
@@ -72,7 +72,7 @@ export function withCache<T extends (...args: any[]) => Promise<any>>(
 		cacheInstance,
 	} = options;
 
-	const fnName = fn.name || "anonymous_function";
+	const fnName = `withCache_${fn.name || "anonymous_function"}`;
 
 	const cachedFn = async (...args: Parameters<T>): Promise<ReturnType<T>> => {
 		const cache: Cache = cacheInstance || getDefaultCache();

Diff for: src/helpers.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { cachedCall, withCache } from "../helpers";
+import { cachedCall, withCache, defaultKeyGenerator } from "../helpers";
 
 // A mock function that simulates an expensive async operation
 async function expensiveFunction(param: string): Promise<string> {
@@ -145,3 +145,74 @@ describe("cachedFunction Wrapper with complex parameters", () => {
 		).toBeGreaterThanOrEqual(500);
 	});
 });
+
+async function noArgFunction(): Promise<string> {
+	return new Promise((resolve) => {
+		setTimeout(() => {
+			resolve("no_arg_result");
+		}, 500);
+	});
+}
+
+describe("cachedCall with no arguments", () => {
+	it("should run the function and cache the result on initial call", async () => {
+		const result = await cachedCall(noArgFunction, {
+			ttl: 2,
+			tags: ["testTag"],
+		});
+		expect(result).toBe("no_arg_result");
+	});
+
+	it("should return cached result on second call", async () => {
+		await cachedCall(noArgFunction, { ttl: 2, tags: ["testTag"] });
+		const startCachedCall = Date.now();
+		const result = await cachedCall(noArgFunction, {
+			ttl: 2,
+			tags: ["testTag"],
+		});
+		const endCachedCall = Date.now();
+		expect(result).toBe("no_arg_result");
+		expect(endCachedCall - startCachedCall).toBeLessThan(100);
+	});
+});
+
+const cachedNoArgFunction = withCache(noArgFunction, {
+	ttl: 3600,
+	tags: ["tag1"],
+});
+
+describe("withCache with no arguments", () => {
+	it("should run the function and cache the result on initial call", async () => {
+		const startFirstCall = Date.now();
+		const cachedResult = await cachedNoArgFunction();
+		const endFirstCall = Date.now();
+		expect(cachedResult).toBe("no_arg_result");
+		expect(endFirstCall - startFirstCall).toBeGreaterThanOrEqual(500);
+	});
+
+	it("should return cached result on second call", async () => {
+		await cachedNoArgFunction();
+		const startCachedCall2 = Date.now();
+		const cachedResult = await cachedNoArgFunction();
+		const endCachedCall2 = Date.now();
+		expect(cachedResult).toBe("no_arg_result");
+		expect(endCachedCall2 - startCachedCall2).toBeLessThan(100);
+	});
+});
+
+describe("defaultKeyGenerator", () => {
+	it("should generate a key with no arguments", () => {
+		const key = defaultKeyGenerator("testFunction", []);
+		expect(key).toMatch(/^testFunction:[a-f0-9]{40}$/);
+	});
+
+	it("should generate a key with null arguments", () => {
+		const key = defaultKeyGenerator("testFunction", null as any);
+		expect(key).toMatch(/^testFunction:[a-f0-9]{40}$/);
+	});
+
+	it("should generate a key with undefined arguments", () => {
+		const key = defaultKeyGenerator("testFunction", undefined);
+		expect(key).toMatch(/^testFunction:[a-f0-9]{40}$/);
+	});
+});