fix: more cache testing and a note in readme

Signed-off-by: tunnckoCore <5038030+tunnckoCore@users.noreply.github.com>

Author: tunnckoCore

README.md

@@ -1,6 +1,6 @@
 # Zagora
 
-[![ci](https://github.com/tunnckoCore/zagora/actions/workflows/ci.yml/badge.svg)](https://github.com/tunnckoCore/zagora/actions/workflows/ci.yml) <!-- COV_BADGE:START -->![coverage](https://badgen.net/badge/coverage/91.24%25/99CC09)<!-- COV_BADGE:END -->
+[![ci](https://github.com/tunnckoCore/zagora/actions/workflows/ci.yml/badge.svg)](https://github.com/tunnckoCore/zagora/actions/workflows/ci.yml) <!-- COV_BADGE:START -->![coverage](https://badgen.net/badge/coverage/96.13%25/99CC09)<!-- COV_BADGE:END -->
 
 Elevate your TypeScript workflow with Zagora: a sleek, bulletproof toolkit for forging type-safe, error-proof functions and libraries that never throw. Powered by StandardSchema-compliant validators like Zod, Valibot, and Arktype, it delivers rock-solid input/output validation and richly typed errors. No routers, no network baggage — just pure, exportable functions ready to supercharge your code. The ultimate streamlined alternative to oRPC and tRPC, stripping away the network layer for unmatched type-safety, simplicity and robustness.
 
@@ -542,6 +542,7 @@ Built-in caching with custom cache adapter. Cache key includes the input, the in
 - if cache method throws, the process never crash - you can find the error at the standard `result.error`
 - failures in cache adapter will be reported as `UNKNOWN_ERROR` in `result.error` with `result.error.cause` set to the error thrown 
 - in future this could change to be `CACHE_ERROR` with `cause`
+- when cache is passed through `.callable` - and has async methods, make sure to await the procedure and ignore the TypeScript warning that "you may not need await here" - you do need to await
 
 ```ts
 const cache = new Map();

src/index.ts

@@ -249,10 +249,12 @@ export class Zagora<
   }
 
   private _createProcedure<
+    TCache,
     TNewContext extends TContext = TContext,
     TKindNames extends
       ResolveErrorKindNames<TErrorsMap> = ResolveErrorKindNames<TErrorsMap>,
   >(context?: TNewContext) {
+    /* v8 ignore next -- @preserve */
     if (typeof this["~zagora"].handler !== "function") {
       this["~zagora"].handler = () => {};
     }
@@ -294,7 +296,7 @@ export class Zagora<
 
     type TResult = ConditionalAsync<ReturnType<THandlerFn>, Result>;
 
-    type TFinalResult = TCacheAdapter extends {
+    type TFinalResult = TCache extends {
       has(key: string): infer A;
       get(key: string): infer B;
       set(key: string, value: unknown): infer C;
@@ -318,13 +320,16 @@ export class Zagora<
   callable<
     TNewContext extends TContext,
     TKindNames extends ResolveErrorKindNames<TErrorsMap>,
-    TNewCacheAdapter extends CacheAdapter,
-  >(options: { context?: TNewContext; cache?: TNewCacheAdapter } = {}) {
+    TCacheDefinitely extends CacheAdapter,
+    TNewCacheAdapter extends TCacheDefinitely | undefined = undefined,
+  >(options: { context?: TNewContext; cache?: TCacheDefinitely } = {}) {
     let za = this;
     if (options.cache) {
-      za = this.cache(options.cache) as any;
+      za = this.cache<TCacheDefinitely>(options.cache) as any;
     }
 
-    return za._createProcedure<TNewContext, TKindNames>(options.context);
+    return za._createProcedure<TNewCacheAdapter, TNewContext, TKindNames>(
+      options.context,
+    );
   }
 }

src/utils.ts

@@ -213,6 +213,7 @@ export function executeHandler(
           "set",
         );
         if (resp instanceof Promise) {
+          /* v8 ignore next -- @preserve */
           return resp.then((resolved) =>
             resolved.ok ? handlerResolved : resolved,
           );

test/main.test.ts

@@ -626,23 +626,94 @@ test("basic in-memory caching/memoization", async () => {
 });
 
 test("cache adapter passed through `.callable` method", async () => {
-  let called = 0;
-  const hello = zagora()
-    .context({ age: 10 })
-    .input(z.string())
-    .handler(({ context }) => {
-      called += 1;
-      return context.age + called;
-    })
-    .callable({ cache: new Map() });
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: ok
+  async function fixture(
+    withSetError = false,
+    withGetError = false,
+    withHasError = false,
+  ) {
+    let called = 0;
+    const cache = new Map();
+    const hello = zagora()
+      .context({ age: 10 })
+      .input(z.string())
+      .handler(({ context }) => {
+        called += 1;
+        return context.age + called;
+      })
+      .callable({
+        cache: {
+          has(key: string) {
+            if (withHasError) {
+              throw new Error("The has is not implemented");
+            }
+            return cache.has(key);
+          },
+          get(key: string) {
+            if (withGetError) {
+              throw new Error("Get method not implemented yet");
+            }
+            return cache.get(key);
+          },
+          async set(key: string, value: any) {
+            if (withSetError) {
+              throw new Error("Set method is not implemented");
+            }
+            cache.set(key, value);
+          },
+        },
+      });
+
+    const res = await hello("foo");
+    if (withSetError || withHasError) {
+      expect(res.ok).toBe(false);
+      if (!res.ok) {
+        expect(res.error.kind).toBe("UNKNOWN_ERROR");
+        expect(res.error.message).toContain(
+          withSetError
+            ? "Failure in async CacheAdapter.set"
+            : "Failure in CacheAdapter.has",
+        );
+        if (withSetError) {
+          expect((res.error as any)?.cause?.message).toContain("Set method is");
+        }
+        if (withHasError) {
+          expect((res.error as any)?.cause?.message).toContain(
+            "The has is not impl",
+          );
+        }
+      }
+
+      return;
+    }
+    expect(res.ok).toBe(true);
+    expect(called, "expects to be called once").toBe(1);
+    expect((res as any).data).toStrictEqual(11);
+
+    const res2 = await hello("foo");
+    if (withGetError) {
+      expect(res2.ok).toBe(false);
+      if (!res2.ok) {
+        expect(res2.error.kind).toBe("UNKNOWN_ERROR");
+        expect(res2.error.message).toContain("Failure in CacheAdapter.get");
+        expect((res2.error as any)?.cause?.message).toContain(
+          "Get method not impl",
+        );
+      }
 
-  const res = hello("foo");
-  expect(res.ok).toBe(true);
-  expect(called, "expects to be called once").toBe(1);
-  expect((res as any).data).toStrictEqual(11);
+      return;
+    }
+    expect(res2.ok).toBe(true);
+    expect(called, "expects to be called only once").toBe(1);
+    expect((res2 as any).data).toStrictEqual(11);
+  }
 
-  const res2 = hello("foo");
-  expect(res2.ok).toBe(true);
-  expect(called, "expects to be called only once").toBe(1);
-  expect((res2 as any).data).toStrictEqual(11);
+  fixture();
+  fixture(true);
+  fixture(true, true);
+  fixture(false, true);
+  fixture(false, true, true);
+  fixture(true, false);
+  fixture(true, true, false);
+  fixture(false, false, true);
 });