@cfast/db 0.4.0 → 0.4.1

package/dist/index.d.ts

@@ -502,6 +502,29 @@ type Db = {
             tables?: string[];
         }) => Promise<void>;
     };
+    /**
+     * Clears the per-instance `with` lookup cache so that the next query
+     * re-runs every grant lookup function.
+     *
+     * In production this is rarely needed because each request gets a fresh
+     * `Db` via `createDb()`. In tests that reuse a single `Db` across grant
+     * mutations (e.g. inserting a new friendship and then querying recipes),
+     * call this after the mutation to avoid stale lookup results.
+     *
+     * For finer-grained control, wrap each logical request in
+     * {@link runWithLookupCache} instead -- that scopes the cache via
+     * `AsyncLocalStorage` so it is automatically discarded at scope exit.
+     *
+     * @example
+     * ```ts
+     * const db = createDb({ ... });
+     * await db.query(recipes).findMany().run(); // populates lookup cache
+     * await db.insert(friendGrants).values({ ... }).run(); // adds new grant
+     * db.clearLookupCache(); // drop stale lookups
+     * await db.query(recipes).findMany().run(); // sees new grant
+     * ```
+     */
+    clearLookupCache: () => void;
 };
 /**
  * Builder for read queries on a single table.

package/dist/index.js

@@ -935,6 +935,9 @@ function buildDb(config, isUnsafe, lookupCache) {
           }
         }
       }
+    },
+    clearLookupCache() {
+      lookupCache.clear();
     }
   };
   return db;
@@ -1059,7 +1062,8 @@ function createTrackingDb(real, perms) {
       }
       return createSentinel();
     },
-    cache: real.cache
+    cache: real.cache,
+    clearLookupCache: () => real.clearLookupCache()
   };
   return trackingDb;
 }

package/llms.txt

@@ -532,6 +532,27 @@ prefer the scoped cache over the `Db`-owned fallback. Pass an explicit
 `LookupCache` instance as the second argument if you want to share a cache
 across multiple sibling `runWithLookupCache` calls.
 
+### db.clearLookupCache(): void
+
+Clears the per-instance cross-table `with` lookup cache on the `Db` instance. This is the imperative counterpart to `runWithLookupCache()` -- instead of scoping a fresh cache via ALS, it resets the instance-owned cache in place.
+
+The primary use case is tests that reuse a single `Db` across grant inserts. After modifying grants, call `db.clearLookupCache()` so subsequent queries re-run `with` lookups against the updated data:
+
+```typescript
+const db = createDb({ d1, schema, grants, user, cache: false });
+
+// Insert a new friend-grant.
+await db.unsafe().insert(friendGrants).values({ grantee: "u1", target: "u2" }).run();
+
+// Without this, the next query would use the stale cached lookup.
+db.clearLookupCache();
+
+const visible = await db.query(recipes).findMany().run();
+expect(visible).toContainEqual(expect.objectContaining({ authorId: "u2" }));
+```
+
+Prefer `runWithLookupCache()` in production code (ALS-scoped, automatic cleanup). Use `clearLookupCache()` when you need a quick manual reset in tests or long-lived workers that don't use the ALS pattern.
+
 ## Integration
 
 - **@cfast/permissions** -- `grants` come from `resolveGrants(permissions, user.roles)`. Permission WHERE clauses are defined via `grant()` in your permissions config.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfast/db",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Permission-aware Drizzle queries for Cloudflare D1",
   "keywords": [
     "cfast",
@@ -34,7 +34,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@cfast/permissions": ">=0.3.0 <0.5.0",
+    "@cfast/permissions": ">=0.3.0 <0.6.0",
     "drizzle-orm": ">=0.35"
   },
   "peerDependenciesMeta": {
@@ -51,7 +51,7 @@
     "tsup": "^8",
     "typescript": "^5.7",
     "vitest": "^4.1.0",
-    "@cfast/permissions": "0.4.0"
+    "@cfast/permissions": "0.5.1"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts",