fix: make .callable accept cache & context, update docs & tests

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

Author: tunnckoCore

README.md

@@ -382,7 +382,9 @@ hello('invalid-keys');
 
 In some advanced scenarios, you may need to pass runtime context to handlers, like `req`, `db`, `user`, sessions, and other dependencies. It's fully typed dependency injection mechanism.
 
-You may or may not provide initial context that will be merged with the context you provide through `.callable`
+You may or may not provide initial context that will be merged with the context you provide through `.callable({ context })`.
+
+Providing context (and cache for that matter) can be done through the `.callable` method - that's useful for passing it from "execution place", not where you "define" your procedures - like server `Request/Response` (fetch API) handler.
 
 ```ts
 const procedure = zagora()
@@ -394,7 +396,7 @@ const procedure = zagora()
   })
   // NOTE: a) you will get intellisense here
   // NOTE: b) you can override context
-  .callable({ userId: 'foo-bar', foo: 'qux' });
+  .callable({ context: { userId: 'foo-bar', foo: 'qux' } });
 
 procedure('charlie');
 // => 'foo-bar has foo -> qux, id = charlie'
@@ -545,7 +547,8 @@ Built-in caching with custom cache adapter. Cache key includes the input, the in
 const cache = new Map();
 
 const procedure = zagora()
-  .cache(cache)
+  // NOTE: you can either pass through `.cache` or through `.callable({ cache })`
+  // .cache(cache)
   .input(z.string())
   // NOTE: the handler is NOT marked as async!
   .handler((_, input) => {
@@ -575,6 +578,8 @@ const proc = zagora()
 const res = await proc(22);
 ```
 
+You can also provide the cache through `.callable({ cache })`. That is useful, if you want to provide it at "execution place", not at "definition place". For example, you'd have a set of procedures written at one place, then throgh "router" or some object that combiens them you want to call them at a `Request/Response` server handler.
+
 
 ### Options Object
 

src/index.ts

@@ -318,7 +318,13 @@ export class Zagora<
   callable<
     TNewContext extends TContext,
     TKindNames extends ResolveErrorKindNames<TErrorsMap>,
-  >(context?: TNewContext) {
-    return this._createProcedure<TNewContext, TKindNames>(context);
+    TNewCacheAdapter extends CacheAdapter,
+  >(options: { context?: TNewContext; cache?: TNewCacheAdapter } = {}) {
+    let za = this;
+    if (options.cache) {
+      za = this.cache(options.cache) as any;
+    }
+
+    return za._createProcedure<TNewContext, TKindNames>(options.context);
   }
 }

test/main.test.ts

@@ -75,7 +75,7 @@ test("context override in callable", () => {
     .handler(({ context }, input) => {
       return `${input}-${context.db}`;
     })
-    .callable({ db: "override" });
+    .callable({ context: { db: "override" } });
 
   const res = fn("baz");
   if (res.ok) {
@@ -624,3 +624,25 @@ test("basic in-memory caching/memoization", async () => {
   const _ = await hello("Bobby");
   expect(called, "Expects `called` to be incremented").toBe(2);
 });
+
+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() });
+
+  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);
+
+  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);
+});