@bb-labs/convex-cache 0.0.1 → 0.0.3

package/README.md

@@ -33,9 +33,9 @@ The client cache stores query results in IndexedDb, enabling instant page loads.
 
 <a aria-label="Client Cache Flowchart" href="https://github.com/bigbang-sdk/convex-cache">
   <picture>
-    <source srcset="https://raw.githubusercontent.com/bigbang-sdk/convex-cache/refs/heads/main/assets/flowchart/client-cache-dark.png" media="(prefers-color-scheme: dark)" />
-    <source srcset="https://raw.githubusercontent.com/bigbang-sdk/convex-cache/refs/heads/main/assets/flowchart/client-cache-light.png" media="(prefers-color-scheme: light)" />
-    <img src="https://raw.githubusercontent.com/bigbang-sdk/convex-cache/refs/heads/main/assets/flowchart/client-cache-light.png" alt="Client Cache Flowchart" referrerpolicy="no-referrer-when-downgrade" />
+    <source srcset="https://raw.githubusercontent.com/beepbop-labs/libraries/refs/heads/main/packages/convex-cache/assets/flowchart/client-cache-dark.png" media="(prefers-color-scheme: dark)" />
+    <source srcset="https://raw.githubusercontent.com/beepbop-labs/libraries/refs/heads/main/packages/convex-cache/assets/flowchart/client-cache-light.png" media="(prefers-color-scheme: light)" />
+    <img src="https://raw.githubusercontent.com/beepbop-labs/libraries/refs/heads/main/packages/convex-cache/assets/flowchart/client-cache-light.png" alt="Client Cache Flowchart" referrerpolicy="no-referrer-when-downgrade" />
   </picture>
 </a>
 
@@ -60,9 +60,9 @@ The server cache (with Next.js) leverages Next.js's native caching system, integ
 
 <a aria-label="Server Cache Flowchart" href="https://github.com/bigbang-sdk/convex-cache">
   <picture>
-    <source srcset="https://raw.githubusercontent.com/bigbang-sdk/convex-cache/refs/heads/main/assets/flowchart/server-cache-dark.png" media="(prefers-color-scheme: dark)" />
-    <source srcset="https://raw.githubusercontent.com/bigbang-sdk/convex-cache/refs/heads/main/assets/flowchart/server-cache-light.png" media="(prefers-color-scheme: light)" />
-    <img src="https://raw.githubusercontent.com/bigbang-sdk/convex-cache/refs/heads/main/assets/flowchart/server-cache-light.png" alt="Server Cache Flowchart" referrerpolicy="no-referrer-when-downgrade" />
+    <source srcset="https://raw.githubusercontent.com/beepbop-labs/libraries/refs/heads/main/packages/convex-cache/assets/flowchart/server-cache-dark.png" media="(prefers-color-scheme: dark)" />
+    <source srcset="https://raw.githubusercontent.com/beepbop-labs/libraries/refs/heads/main/packages/convex-cache/assets/flowchart/server-cache-light.png" media="(prefers-color-scheme: light)" />
+    <img src="https://raw.githubusercontent.com/beepbop-labs/libraries/refs/heads/main/packages/convex-cache/assets/flowchart/server-cache-light.png" alt="Server Cache Flowchart" referrerpolicy="no-referrer-when-downgrade" />
   </picture>
 </a>
 

package/dist/cli/fns/dev.js

@@ -1,6 +1,7 @@
 // src/cli/fns/dev.ts
 import { DirWatcher } from "../lib/dir-watcher.js";
 import { ConvexRunner } from "./fns/convex-runner.js";
+import { runCmd } from "../lib/package-cmds.js";
 import { getConvexDir } from "../lib/convex-config.js";
 /**
  * Start a one-off Convex dev run and then watch the Convex directory

package/dist/cli/fns/fns/convex-runner.js

@@ -7,65 +7,66 @@ import { runCmd, runFileCmd } from "../../lib/package-cmds.js";
  * Uses ShellRunner under the hood and ensures only one run happens at a time.
  */
 export class ConvexRunner {
+    tasks = new ShellRunner();
+    skipConvex;
+    isRunning = false;
     constructor({ skipConvex = false }) {
-        this.tasks = new ShellRunner();
-        this.isRunning = false;
-        /**
-         * Cancel any in-flight Convex task run.
-         * This will cause the current runOnce() to reject with a "cancelled" error.
-         */
-        this.cancel = () => {
-            if (!this.isRunning)
-                return;
-            this.tasks.cancelAll();
-        };
-        this.resolveCurrentPath = () => {
-            const __filename = fileURLToPath(import.meta.url);
-            const __dirname = path.dirname(__filename);
-            return __dirname;
-        };
-        /**
-         * Run the Convex command once, then regenerate the Zod schema.
-         * If a run is already in progress, this is a no-op.
-         * If skipConvex is true, skips the Convex command and only generates schemas.
-         */
-        this.runOnce = async () => {
-            if (this.isRunning)
-                return;
-            this.isRunning = true;
-            this.tasks.resetCancelled();
-            try {
-                if (!this.skipConvex) {
-                    const convexCmd = await runCmd("convex dev --once");
-                    await this.tasks.run(convexCmd, {
-                        kind: "convex",
-                        label: "➡️  Uploading functions to Convex...",
-                        successMessage: "✅ Convex functions uploaded",
-                    });
-                }
-                const generateSchemaPath = path.join(this.resolveCurrentPath(), "generate-z-schema/generate.js");
-                const generateSchemaCmd = await runFileCmd(generateSchemaPath);
-                await this.tasks.run(generateSchemaCmd, {
-                    kind: "schema",
-                    label: "➡️  Generating Zod schemas...",
-                    successMessage: "✅  Zod schemas generated",
-                });
-                console.log(`\n👀 Watching for any changes...`);
-            }
-            catch (err) {
-                // Ignore cancellations from ShellRunner, log everything else.
-                if (!(err instanceof ShellRunnerError && err.message === "cancelled") && (typeof err !== "object" || err === null || err.message !== "cancelled")) {
-                    console.error("⚠️  Convex run failed:", err);
-                }
-            }
-            finally {
-                this.isRunning = false;
-                this.tasks.resetCancelled();
-            }
-        };
         this.skipConvex = skipConvex;
     }
     get running() {
         return this.isRunning;
     }
+    /**
+     * Cancel any in-flight Convex task run.
+     * This will cause the current runOnce() to reject with a "cancelled" error.
+     */
+    cancel = () => {
+        if (!this.isRunning)
+            return;
+        this.tasks.cancelAll();
+    };
+    resolveCurrentPath = () => {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        return __dirname;
+    };
+    /**
+     * Run the Convex command once, then regenerate the Zod schema.
+     * If a run is already in progress, this is a no-op.
+     * If skipConvex is true, skips the Convex command and only generates schemas.
+     */
+    runOnce = async () => {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        this.tasks.resetCancelled();
+        try {
+            if (!this.skipConvex) {
+                const convexCmd = await runCmd("convex dev --once");
+                await this.tasks.run(convexCmd, {
+                    kind: "convex",
+                    label: "➡️  Uploading functions to Convex...",
+                    successMessage: "✅ Convex functions uploaded",
+                });
+            }
+            const generateSchemaPath = path.join(this.resolveCurrentPath(), "generate-z-schema/generate.js");
+            const generateSchemaCmd = await runFileCmd(generateSchemaPath);
+            await this.tasks.run(generateSchemaCmd, {
+                kind: "schema",
+                label: "➡️  Generating Zod schemas...",
+                successMessage: "✅  Zod schemas generated",
+            });
+            console.log(`\n👀 Watching for any changes...`);
+        }
+        catch (err) {
+            // Ignore cancellations from ShellRunner, log everything else.
+            if (!(err instanceof ShellRunnerError && err.message === "cancelled") && (typeof err !== "object" || err === null || err.message !== "cancelled")) {
+                console.error("⚠️  Convex run failed:", err);
+            }
+        }
+        finally {
+            this.isRunning = false;
+            this.tasks.resetCancelled();
+        }
+    };
 }

package/dist/cli/fns/fns/generate-z-schema/fns/load-convex.d.ts

@@ -1,4 +1,4 @@
-import { AnyApi } from "convex/server";
+import type { AnyApi } from "convex/server";
 export declare const loadConvex: () => Promise<{
     convexDir: string;
     api: AnyApi;

package/dist/cli/fns/fns/generate-z-schema/fns/load-convex.js

@@ -24,7 +24,10 @@ export const loadConvexApi = async (convexDir) => {
     ];
     const existing = candidates.find((p) => fs.existsSync(p));
     if (!existing) {
-        console.warn(["⚠️  No convex/_generated/api.{ts,js,mjs,cjs} found in this project.", '⚠️  Skipping schema extraction. Run "npx convex dev" or "npx convex codegen" first.'].join("\n"));
+        console.warn([
+            "⚠️  No convex/_generated/api.{ts,js,mjs,cjs} found in this project.",
+            '⚠️  Skipping schema extraction. Run "npx convex dev" or "npx convex codegen" first.',
+        ].join("\n"));
         return null;
     }
     try {

package/dist/cli/fns/fns/generate-z-schema/generate.d.ts

@@ -1,4 +1,4 @@
-import { ValidatorJSON } from "convex/values";
+import type { ValidatorJSON } from "convex/values";
 export type SchemaEntry = {
     fnName: string;
     schemaJson: {

package/dist/cli/fns/fns/generate-z-schema/utils/find-fn-ref.d.ts

@@ -1,4 +1,4 @@
-import { AnyApi, FunctionReference } from "convex/server";
+import type { AnyApi, FunctionReference } from "convex/server";
 /**
  * Walk the convex API object to find a FunctionReference.
  */

package/dist/cli/lib/dir-watcher.js

@@ -6,54 +6,17 @@ import path from "path";
  * after changes settle for `debounceMs` milliseconds.
  */
 export class DirWatcher {
+    rootDir;
+    rootLabel;
+    recursive;
+    debounceMs;
+    shouldIgnore;
+    onChange;
+    debounceTimer = null;
+    lastRelPath = null;
+    watcher = null;
+    started = false;
     constructor(options) {
-        this.debounceTimer = null;
-        this.lastRelPath = null;
-        this.watcher = null;
-        this.started = false;
-        /**
-         * Start watching the directory.
-         * Exits the process if the root directory does not exist or watcher fails.
-         */
-        this.start = () => {
-            if (this.started)
-                return;
-            if (!fs.existsSync(this.rootDir)) {
-                console.error(`watch root not found: ${this.rootDir}`);
-                process.exit(1);
-            }
-            try {
-                this.watcher = fs.watch(this.rootDir, { recursive: this.recursive }, (eventType, filename) => {
-                    this.handleFsEvent(eventType, filename);
-                });
-                this.watcher.on("error", (err) => {
-                    console.error(`fs.watch error for ${this.rootDir}:`, err);
-                    this.stop();
-                    // Keep behavior simple & explicit: fail hard on watcher errors
-                    process.exit(1);
-                });
-                this.started = true;
-            }
-            catch (err) {
-                console.error(`Failed to start fs.watch on ${this.rootDir} (recursive=${this.recursive}):`, err);
-                process.exit(1);
-            }
-        };
-        /**
-         * Stop watching the directory and clear any pending debounce timer.
-         */
-        this.stop = () => {
-            if (this.watcher) {
-                this.watcher.close();
-                this.watcher = null;
-            }
-            if (this.debounceTimer) {
-                clearTimeout(this.debounceTimer);
-                this.debounceTimer = null;
-            }
-            this.lastRelPath = null;
-            this.started = false;
-        };
         const { rootDir, recursive = true, debounceMs = 200, shouldIgnore, onChange } = options;
         // Normalize to an absolute path to avoid ambiguity
         this.rootDir = path.resolve(rootDir);
@@ -63,6 +26,49 @@ export class DirWatcher {
         this.shouldIgnore = shouldIgnore;
         this.onChange = onChange;
     }
+    /**
+     * Start watching the directory.
+     * Exits the process if the root directory does not exist or watcher fails.
+     */
+    start = () => {
+        if (this.started)
+            return;
+        if (!fs.existsSync(this.rootDir)) {
+            console.error(`watch root not found: ${this.rootDir}`);
+            process.exit(1);
+        }
+        try {
+            this.watcher = fs.watch(this.rootDir, { recursive: this.recursive }, (eventType, filename) => {
+                this.handleFsEvent(eventType, filename);
+            });
+            this.watcher.on("error", (err) => {
+                console.error(`fs.watch error for ${this.rootDir}:`, err);
+                this.stop();
+                // Keep behavior simple & explicit: fail hard on watcher errors
+                process.exit(1);
+            });
+            this.started = true;
+        }
+        catch (err) {
+            console.error(`Failed to start fs.watch on ${this.rootDir} (recursive=${this.recursive}):`, err);
+            process.exit(1);
+        }
+    };
+    /**
+     * Stop watching the directory and clear any pending debounce timer.
+     */
+    stop = () => {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        this.lastRelPath = null;
+        this.started = false;
+    };
     /**
      * Internal handler for fs.watch events.
      * Keeps behavior identical to the original implementation:

package/dist/cli/lib/shell-runner.js

@@ -1,5 +1,8 @@
 import { spawn } from "child_process";
 export class ShellRunnerError extends Error {
+    kind;
+    code;
+    signal;
     constructor(message, kind, code = null, signal = null) {
         super(message);
         this.kind = kind;
@@ -13,121 +16,119 @@ export class ShellRunnerError extends Error {
  * and allows cancelling all running processes.
  */
 export class ShellRunner {
-    constructor() {
-        this.currentProcs = new Map();
+    currentProcs = new Map();
+    cancelled = false;
+    get isCancelled() {
+        return this.cancelled;
+    }
+    /**
+     * Reset the internal "cancelled" flag back to false.
+     * Does not restart any cancelled processes; it only affects
+     * how subsequent runs behave.
+     */
+    resetCancelled = () => {
         this.cancelled = false;
-        /**
-         * Reset the internal "cancelled" flag back to false.
-         * Does not restart any cancelled processes; it only affects
-         * how subsequent runs behave.
-         */
-        this.resetCancelled = () => {
-            this.cancelled = false;
-        };
-        /**
-         * Run a shell command with the given options.
-         *
-         * Resolves on successful exit code (0), rejects otherwise,
-         * or if the runner is cancelled / AbortSignal aborts / a process of this kind is already running.
-         */
-        this.run = async (command, options) => {
-            const { label, kind, successMessage, shell = true, spawnOptions, abortSignal } = options;
-            // Fast-fail if globally cancelled or already aborted.
-            if (this.cancelled) {
-                throw new ShellRunnerError("ShellRunner is cancelled", kind);
-            }
-            if (abortSignal?.aborted) {
-                throw new ShellRunnerError("Run aborted before start", kind);
-            }
-            // Enforce single process per kind.
-            if (this.currentProcs.has(kind)) {
-                throw new ShellRunnerError(`A task of kind "${kind}" is already running`, kind);
+    };
+    /**
+     * Run a shell command with the given options.
+     *
+     * Resolves on successful exit code (0), rejects otherwise,
+     * or if the runner is cancelled / AbortSignal aborts / a process of this kind is already running.
+     */
+    run = async (command, options) => {
+        const { label, kind, successMessage, shell = true, spawnOptions, abortSignal } = options;
+        // Fast-fail if globally cancelled or already aborted.
+        if (this.cancelled) {
+            throw new ShellRunnerError("ShellRunner is cancelled", kind);
+        }
+        if (abortSignal?.aborted) {
+            throw new ShellRunnerError("Run aborted before start", kind);
+        }
+        // Enforce single process per kind.
+        if (this.currentProcs.has(kind)) {
+            throw new ShellRunnerError(`A task of kind "${kind}" is already running`, kind);
+        }
+        console.log(`\n${label}`);
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, {
+                shell,
+                stdio: ["inherit", "inherit", "inherit"],
+                ...spawnOptions,
+            });
+            this.currentProcs.set(kind, child);
+            // Support AbortSignal-based cancellation
+            const abortHandler = () => {
+                if (!child.killed) {
+                    child.kill("SIGINT");
+                }
+            };
+            if (abortSignal) {
+                abortSignal.addEventListener("abort", abortHandler, { once: true });
             }
-            console.log(`\n${label}`);
-            return new Promise((resolve, reject) => {
-                const child = spawn(command, {
-                    shell,
-                    stdio: ["inherit", "inherit", "inherit"],
-                    ...spawnOptions,
-                });
-                this.currentProcs.set(kind, child);
-                // Support AbortSignal-based cancellation
-                const abortHandler = () => {
-                    if (!child.killed) {
-                        child.kill("SIGINT");
-                    }
-                };
+            let settled = false;
+            const settle = (fn) => {
+                if (settled)
+                    return;
+                settled = true;
+                // Cleanup
+                if (this.currentProcs.get(kind) === child) {
+                    this.currentProcs.delete(kind);
+                }
                 if (abortSignal) {
-                    abortSignal.addEventListener("abort", abortHandler, { once: true });
+                    abortSignal.removeEventListener("abort", abortHandler);
                 }
-                let settled = false;
-                const settle = (fn) => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    // Cleanup
-                    if (this.currentProcs.get(kind) === child) {
-                        this.currentProcs.delete(kind);
-                    }
-                    if (abortSignal) {
-                        abortSignal.removeEventListener("abort", abortHandler);
+                fn();
+            };
+            child.on("exit", (code, signal) => {
+                settle(() => {
+                    if (this.cancelled || abortSignal?.aborted) {
+                        return reject(new ShellRunnerError("cancelled", kind, code, signal));
                     }
-                    fn();
-                };
-                child.on("exit", (code, signal) => {
-                    settle(() => {
-                        if (this.cancelled || abortSignal?.aborted) {
-                            return reject(new ShellRunnerError("cancelled", kind, code, signal));
+                    if (code === 0) {
+                        if (successMessage) {
+                            console.log(successMessage);
                         }
-                        if (code === 0) {
-                            if (successMessage) {
-                                console.log(successMessage);
-                            }
-                            return resolve();
-                        }
-                        console.error(`❌ ${label} failed (code=${code ?? "unknown"}, signal=${signal ?? "none"})`);
-                        reject(new ShellRunnerError(`${label} failed with code ${code ?? "unknown"}`, kind, code, signal));
-                    });
+                        return resolve();
+                    }
+                    console.error(`❌ ${label} failed (code=${code ?? "unknown"}, signal=${signal ?? "none"})`);
+                    reject(new ShellRunnerError(`${label} failed with code ${code ?? "unknown"}`, kind, code, signal));
                 });
-                child.on("error", (err) => {
-                    settle(() => {
-                        console.error(`❌ Failed to start ${label}:`, err);
-                        reject(err);
-                    });
+            });
+            child.on("error", (err) => {
+                settle(() => {
+                    console.error(`❌ Failed to start ${label}:`, err);
+                    reject(err);
                 });
             });
-        };
-        /**
-         * Mark the runner as cancelled and send the given signal
-         * (default SIGINT) to all tracked child processes.
-         */
-        this.cancelAll = (signal = "SIGINT") => {
-            this.cancelled = true;
-            for (const child of this.currentProcs.values()) {
-                try {
-                    child.kill(signal);
-                }
-                catch {
-                    // ignore
-                }
-            }
-        };
-        /**
-         * Cancel a single running task kind, if present.
-         */
-        this.cancelKind = (kind, signal = "SIGINT") => {
-            const child = this.currentProcs.get(kind);
-            if (!child)
-                return;
+        });
+    };
+    /**
+     * Mark the runner as cancelled and send the given signal
+     * (default SIGINT) to all tracked child processes.
+     */
+    cancelAll = (signal = "SIGINT") => {
+        this.cancelled = true;
+        for (const child of this.currentProcs.values()) {
             try {
                 child.kill(signal);
             }
             catch {
                 // ignore
             }
-        };
-    }
-    get isCancelled() {
-        return this.cancelled;
-    }
+        }
+    };
+    /**
+     * Cancel a single running task kind, if present.
+     */
+    cancelKind = (kind, signal = "SIGINT") => {
+        const child = this.currentProcs.get(kind);
+        if (!child)
+            return;
+        try {
+            child.kill(signal);
+        }
+        catch {
+            // ignore
+        }
+    };
 }

package/dist/convex-cache/adapters/next/fns/build-preloader.d.ts

@@ -1,5 +1,5 @@
-import { Q_Query } from "../../../core/types/types/query";
-import { PQ_Query } from "../../../core/types/types/paginated-query";
-import { PreloadQueryReturn, T_PreloadQueryParams } from "./preload-query";
-import { T_SchemaMap } from "../../../types/schema-map";
+import type { Q_Query } from "../../../core/types/types/query";
+import type { PQ_Query } from "../../../core/types/types/paginated-query";
+import type { PreloadQueryReturn, T_PreloadQueryParams } from "./preload-query";
+import type { T_SchemaMap } from "../../../types/schema-map";
 export declare function buildPreloader(schemaMap: T_SchemaMap): <Q extends Q_Query | PQ_Query>(params: Omit<T_PreloadQueryParams<Q>, "schemaMap">) => Promise<PreloadQueryReturn<Q>>;

package/dist/convex-cache/adapters/next/fns/preload-query.d.ts

@@ -1,7 +1,7 @@
-import { PQ_CachedResult, PQ_Query } from "../../../core/types/types/paginated-query";
-import { Q_Query, Q_Result } from "../../../core/types/types/query";
-import { PQ_ArgsPreloaded, PQ_OptionsPreloaded, Q_ArgsPreloaded, Q_OptionsPreloaded } from "../types/preloaded";
-import { T_SchemaMap } from "../../../types/schema-map";
+import type { PQ_CachedResult, PQ_Query } from "../../../core/types/types/paginated-query";
+import type { Q_Query, Q_Result } from "../../../core/types/types/query";
+import type { PQ_ArgsPreloaded, PQ_OptionsPreloaded, Q_ArgsPreloaded, Q_OptionsPreloaded } from "../types/preloaded";
+import type { T_SchemaMap } from "../../../types/schema-map";
 export type PreloadQueryReturn<Q extends Q_Query | PQ_Query> = Q extends PQ_Query ? PQ_CachedResult<Q> | undefined : Q_Result<Q> | undefined;
 export type T_PreloadQueryParams<Q extends Q_Query | PQ_Query> = {
     query: Q;

package/dist/convex-cache/adapters/next/hooks/hooks.d.ts

@@ -1,8 +1,8 @@
-import { Q_Query, PQ_Query } from "../../../core/types";
-import { T_UseCachedPaginatedQueryServer } from "../../../core/server-cache/queries/paginated-query";
-import { T_UseCachedQueryServer } from "../../../core/server-cache/queries/query";
+import type { Q_Query, PQ_Query } from "../../../core/types";
+import { type T_UseCachedPaginatedQueryServer } from "../../../core/server-cache/queries/paginated-query";
+import { type T_UseCachedQueryServer } from "../../../core/server-cache/queries/query";
 type T_UseCachedQueryServerParams<Q extends Q_Query> = Omit<T_UseCachedQueryServer<Q>, "revalidateCache">;
-export declare const useCachedQueryServer: <Q extends Q_Query>({ query, args, preloadedData }: T_UseCachedQueryServerParams<Q>) => import("../../../core/types").Q_Result<Q> | undefined;
+export declare const useCachedQueryServer: <Q extends Q_Query>({ query, args, preloadedData, }: T_UseCachedQueryServerParams<Q>) => import("../../../core/types").Q_Result<Q> | undefined;
 type T_UseCachedPaginatedQueryServerParams<Q extends PQ_Query> = Omit<T_UseCachedPaginatedQueryServer<Q>, "revalidateCache">;
-export declare const useCachedPaginatedQueryServer: <Q extends PQ_Query>({ query, args, options, preloadedData }: T_UseCachedPaginatedQueryServerParams<Q>) => import("../../../core/types").PQ_Result<Q>;
+export declare const useCachedPaginatedQueryServer: <Q extends PQ_Query>({ query, args, options, preloadedData, }: T_UseCachedPaginatedQueryServerParams<Q>) => import("../../../core/types").PQ_Result<Q>;
 export {};

package/dist/convex-cache/adapters/next/hooks/hooks.js

@@ -1,9 +1,15 @@
-import { _useCachedPaginatedQueryServer } from "../../../core/server-cache/queries/paginated-query";
+import { _useCachedPaginatedQueryServer, } from "../../../core/server-cache/queries/paginated-query";
 import { _useCachedQueryServer } from "../../../core/server-cache/queries/query";
 import { revalidatePaginatedQueryCache, revalidateQueryCache } from "../lib/revalidate-query-cache";
-export const useCachedQueryServer = ({ query, args, preloadedData }) => {
+export const useCachedQueryServer = ({ query, args, preloadedData, }) => {
     return _useCachedQueryServer({ query, args, preloadedData, revalidateCache: revalidateQueryCache });
 };
-export const useCachedPaginatedQueryServer = ({ query, args, options, preloadedData }) => {
-    return _useCachedPaginatedQueryServer({ query, args, options, preloadedData, revalidateCache: revalidatePaginatedQueryCache });
+export const useCachedPaginatedQueryServer = ({ query, args, options, preloadedData, }) => {
+    return _useCachedPaginatedQueryServer({
+        query,
+        args,
+        options,
+        preloadedData,
+        revalidateCache: revalidatePaginatedQueryCache,
+    });
 };

package/dist/convex-cache/adapters/next/lib/revalidate-query-cache.d.ts

@@ -1,7 +1,7 @@
-import { Q_Query } from "../../../core/types/types/query";
-import { PQ_Query } from "../../../core/types/types/paginated-query";
-import { PQ_ArgsPreloaded, Q_ArgsPreloaded } from "../types/preloaded";
-export declare const revalidateQueryCache: <Q extends Q_Query>({ query, args }: {
+import type { Q_Query } from "../../../core/types/types/query";
+import type { PQ_Query } from "../../../core/types/types/paginated-query";
+import type { PQ_ArgsPreloaded, Q_ArgsPreloaded } from "../types/preloaded";
+export declare const revalidateQueryCache: <Q extends Q_Query>({ query, args, }: {
     query: Q;
     args: Q_ArgsPreloaded<Q>;
 }) => Promise<void>;
@@ -9,5 +9,5 @@ type T_RevalidatePaginatedQueryCacheParams<Q extends PQ_Query> = {
     query: Q;
     args: PQ_ArgsPreloaded<Q>;
 };
-export declare const revalidatePaginatedQueryCache: <Q extends PQ_Query>({ query, args }: T_RevalidatePaginatedQueryCacheParams<Q>) => Promise<void>;
+export declare const revalidatePaginatedQueryCache: <Q extends PQ_Query>({ query, args, }: T_RevalidatePaginatedQueryCacheParams<Q>) => Promise<void>;
 export {};

package/dist/convex-cache/adapters/next/lib/revalidate-query-cache.js

@@ -1,7 +1,7 @@
 import { makeQueryKey } from "../../../core/helpers/utils/query-key";
 import { getFunctionName } from "convex/server";
 import { revalidateCache } from "../server-fns/revalidate-cache";
-export const revalidateQueryCache = async ({ query, args }) => {
+export const revalidateQueryCache = async ({ query, args, }) => {
     const queryName = getFunctionName(query);
     const { tag } = makeQueryKey({
         queryName,
@@ -10,7 +10,7 @@ export const revalidateQueryCache = async ({ query, args }) => {
     });
     await revalidateCache({ tag });
 };
-export const revalidatePaginatedQueryCache = async ({ query, args }) => {
+export const revalidatePaginatedQueryCache = async ({ query, args, }) => {
     const queryName = getFunctionName(query);
     const { tag } = makeQueryKey({
         queryName,

package/dist/convex-cache/adapters/next/server-fns/preload-query.d.ts

@@ -1,16 +1,16 @@
-import { Q_Query, Q_Result } from "../../../core/types/types/query";
-import { PQ_CachedResult, PQ_Query } from "../../../core/types/types/paginated-query";
+import type { Q_Query, Q_Result } from "../../../core/types/types/query";
+import type { PQ_CachedResult, PQ_Query } from "../../../core/types/types/paginated-query";
 import type { PQ_ArgsPreloaded, PQ_OptionsPreloaded, Q_ArgsPreloaded, Q_OptionsPreloaded } from "../types/preloaded";
 type T_PreloadQueryParams<Q extends Q_Query> = {
     queryName: string;
     args: Q_ArgsPreloaded<Q>;
     options?: Q_OptionsPreloaded<Q>;
 };
-export declare const _preloadQuery: ({ queryName, args, options }: T_PreloadQueryParams<Q_Query>) => Promise<Q_Result<Q_Query>>;
+export declare const _preloadQuery: ({ queryName, args, options, }: T_PreloadQueryParams<Q_Query>) => Promise<Q_Result<Q_Query>>;
 type T_PreloadPaginatedQueryParams<Q extends PQ_Query> = {
     queryName: string;
     args: PQ_ArgsPreloaded<Q>;
     options?: PQ_OptionsPreloaded<Q>;
 };
-export declare const _preloadPaginatedQuery: ({ queryName, args, options }: T_PreloadPaginatedQueryParams<PQ_Query>) => Promise<PQ_CachedResult<PQ_Query>>;
+export declare const _preloadPaginatedQuery: ({ queryName, args, options, }: T_PreloadPaginatedQueryParams<PQ_Query>) => Promise<PQ_CachedResult<PQ_Query>>;
 export {};

package/dist/convex-cache/adapters/next/server-fns/preload-query.js

@@ -3,7 +3,7 @@ import { fetchQuery } from "convex/nextjs";
 import { cacheLife, cacheTag } from "next/cache";
 import { makeQueryKey } from "../../../core/helpers/utils/query-key";
 import { defaultCacheProfile } from "../utils/cache-profile";
-export const _preloadQuery = async ({ queryName, args, options }) => {
+export const _preloadQuery = async ({ queryName, args, options, }) => {
     "use cache";
     const { tag } = makeQueryKey({ queryName, args, kind: "query" });
     cacheTag(tag);
@@ -13,7 +13,7 @@ export const _preloadQuery = async ({ queryName, args, options }) => {
     const result = await fetchQuery(fnRef, ...argsTuple);
     return result;
 };
-export const _preloadPaginatedQuery = async ({ queryName, args, options }) => {
+export const _preloadPaginatedQuery = async ({ queryName, args, options, }) => {
     "use cache";
     const { tag } = makeQueryKey({ queryName, args, kind: "paginated" });
     cacheTag(tag);
@@ -23,7 +23,7 @@ export const _preloadPaginatedQuery = async ({ queryName, args, options }) => {
     const result = await fetchQuery(fnRef, ...argsTuple);
     return convertPaginatedResultForClient({ result });
 };
-const convertPaginatedResultForClient = ({ result }) => {
+const convertPaginatedResultForClient = ({ result, }) => {
     return {
         results: result.page,
         status: "Exhausted",

package/dist/convex-cache/adapters/next/types/preloaded.d.ts

@@ -1,7 +1,7 @@
-import { ArgsAndOptions } from "convex/server";
-import { PQ_Query } from "../../../core/types/types/paginated-query";
-import { Q_Query } from "../../../core/types/types/query";
-import { NextjsOptions } from "convex/nextjs";
+import type { ArgsAndOptions } from "convex/server";
+import type { PQ_Query } from "../../../core/types/types/paginated-query";
+import type { Q_Query } from "../../../core/types/types/query";
+import type { NextjsOptions } from "convex/nextjs";
 export type Q_ArgsPreloaded<Q extends Q_Query> = ArgsAndOptions<Q, NextjsOptions>[0];
 export type PQ_ArgsPreloaded<Q extends PQ_Query> = ArgsAndOptions<Q, NextjsOptions>[0];
 export type Q_OptionsPreloaded<Q extends Q_Query> = ArgsAndOptions<Q, NextjsOptions>[1];

package/dist/convex-cache/adapters/react/hooks/hooks.d.ts

@@ -1,6 +1,6 @@
-import { T_UseCachedPaginatedQueryClient } from "../../../core/client-cache/queries/paginated-query";
-import { Q_Query, PQ_Query } from "../../../core/types";
-import { T_UseCachedQueryClient } from "../../../core/client-cache/queries/query";
+import type { T_UseCachedPaginatedQueryClient } from "../../../core/client-cache/queries/paginated-query";
+import type { Q_Query, PQ_Query } from "../../../core/types";
+import { type T_UseCachedQueryClient } from "../../../core/client-cache/queries/query";
 type T_UseQuery<Q extends Q_Query> = Omit<T_UseCachedQueryClient<Q>, "schemaMap" | "useLocalDb">;
 type T_UsePaginatedQuery<Q extends PQ_Query> = Omit<T_UseCachedPaginatedQueryClient<Q>, "schemaMap" | "useLocalDb">;
 export declare const useCachedQueryClient: <Q extends Q_Query>({ query, args }: T_UseQuery<Q>) => import("../../../core/types").Q_Result<Q> | undefined;

package/dist/convex-cache/adapters/react/hooks/hooks.js

@@ -8,5 +8,11 @@ export const useCachedQueryClient = ({ query, args }) => {
 };
 export const useCachedPaginatedQueryClient = ({ query, args, options }) => {
     const { schemaMap, useLocalDb } = useConvexProvider();
-    return _useCachedPaginatedQueryClient({ query, args, options, schemaMap, useLocalDb: (useLocalDb ?? useLocalDbDefault) });
+    return _useCachedPaginatedQueryClient({
+        query,
+        args,
+        options,
+        schemaMap,
+        useLocalDb: (useLocalDb ?? useLocalDbDefault),
+    });
 };

package/dist/convex-cache/adapters/react/provider/provider.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useContext } from "react";
+import { useLocalDb as useLocalDbDefault } from "@bb-labs/local-db";
 const convexCacheContext = createContext({
     schemaMap: undefined,
     useLocalDb: undefined,

package/dist/convex-cache/core/client-cache/helpers/hooks/use-client-cache.d.ts

@@ -6,5 +6,5 @@ type T_UseClientCache<T> = {
     schema: z.ZodSchema<T>;
     useLocalDb: typeof useLocalDbDefault<T>;
 };
-export declare const useClientCache: <T>({ storageKey, raw, schema, useLocalDb }: T_UseClientCache<T>) => T | null | undefined;
+export declare const useClientCache: <T>({ storageKey, raw, schema, useLocalDb, }: T_UseClientCache<T>) => T | null | undefined;
 export {};

package/dist/convex-cache/core/client-cache/helpers/hooks/use-client-cache.js

@@ -1,6 +1,8 @@
+import { useLocalDb as useLocalDbDefault } from "@bb-labs/local-db";
 import { useEffect } from "react";
-import deepEqual from "fast-deep-equal";
-export const useClientCache = ({ storageKey, raw, schema, useLocalDb }) => {
+import { isDeepEqual } from "@bb-labs/deep-equal";
+import { z } from "zod";
+export const useClientCache = ({ storageKey, raw, schema, useLocalDb, }) => {
     const { value: stored, setValue: setStored } = useLocalDb({
         key: storageKey,
         schema,
@@ -9,7 +11,7 @@ export const useClientCache = ({ storageKey, raw, schema, useLocalDb }) => {
         storeName: "local-store",
     });
     useEffect(() => {
-        if (raw !== undefined && !deepEqual(raw, stored))
+        if (raw !== undefined && !isDeepEqual(raw, stored))
             setStored(raw);
     }, [raw, stored, setStored]);
     return stored;

package/dist/convex-cache/core/client-cache/queries/paginated-query.d.ts

@@ -1,4 +1,4 @@
-import { PQ_Query, PQ_Args, PQ_Result, PQ_CachedResult } from "../../types/types/paginated-query";
+import type { PQ_Query, PQ_Args, PQ_Result, PQ_CachedResult } from "../../types/types/paginated-query";
 import type { T_SchemaMap } from "../../../types/schema-map";
 import { useLocalDb as useLocalDbDefault } from "@bb-labs/local-db";
 export type T_UseCachedPaginatedQueryClient<Q extends PQ_Query> = {
@@ -10,4 +10,4 @@ export type T_UseCachedPaginatedQueryClient<Q extends PQ_Query> = {
     schemaMap: T_SchemaMap;
     useLocalDb: typeof useLocalDbDefault<PQ_CachedResult<Q>>;
 };
-export declare const _useCachedPaginatedQueryClient: <Q extends PQ_Query>({ query, args, options, schemaMap, useLocalDb }: T_UseCachedPaginatedQueryClient<Q>) => PQ_Result<Q>;
+export declare const _useCachedPaginatedQueryClient: <Q extends PQ_Query>({ query, args, options, schemaMap, useLocalDb, }: T_UseCachedPaginatedQueryClient<Q>) => PQ_Result<Q>;

package/dist/convex-cache/core/client-cache/queries/paginated-query.js

@@ -4,7 +4,8 @@ import { useClientCache } from "../helpers/hooks/use-client-cache";
 import { getFunctionName } from "convex/server";
 import { useMemo } from "react";
 import { fetchSchemaFromMap } from "../../helpers/utils/fetch-schema-from-map";
-export const _useCachedPaginatedQueryClient = ({ query, args, options, schemaMap, useLocalDb }) => {
+import { useLocalDb as useLocalDbDefault } from "@bb-labs/local-db";
+export const _useCachedPaginatedQueryClient = ({ query, args, options, schemaMap, useLocalDb, }) => {
     const queryName = useMemo(() => getFunctionName(query), [query]);
     const schema = useMemo(() => fetchSchemaFromMap({
         queryName,

package/dist/convex-cache/core/client-cache/queries/query.d.ts

@@ -1,4 +1,4 @@
-import { Q_Query, Q_Args, Q_Result } from "../../types/types/query";
+import type { Q_Query, Q_Args, Q_Result } from "../../types/types/query";
 import type { T_SchemaMap } from "../../../types/schema-map";
 import { useLocalDb as useLocalDbDefault } from "@bb-labs/local-db";
 export type T_UseCachedQueryClient<Q extends Q_Query> = {
@@ -7,4 +7,4 @@ export type T_UseCachedQueryClient<Q extends Q_Query> = {
     schemaMap: T_SchemaMap;
     useLocalDb: typeof useLocalDbDefault<Q_Result<Q>>;
 };
-export declare const _useCachedQueryClient: <Q extends Q_Query>({ query, args, schemaMap, useLocalDb }: T_UseCachedQueryClient<Q>) => Q_Result<Q> | undefined;
+export declare const _useCachedQueryClient: <Q extends Q_Query>({ query, args, schemaMap, useLocalDb, }: T_UseCachedQueryClient<Q>) => Q_Result<Q> | undefined;

package/dist/convex-cache/core/client-cache/queries/query.js

@@ -3,8 +3,9 @@ import { getFunctionName } from "convex/server";
 import { useQueryKey } from "../helpers/hooks/use-query-key";
 import { useClientCache } from "../helpers/hooks/use-client-cache";
 import { useMemo } from "react";
+import { useLocalDb as useLocalDbDefault } from "@bb-labs/local-db";
 import { fetchSchemaFromMap } from "../../helpers/utils/fetch-schema-from-map";
-export const _useCachedQueryClient = ({ query, args, schemaMap, useLocalDb }) => {
+export const _useCachedQueryClient = ({ query, args, schemaMap, useLocalDb, }) => {
     const queryName = useMemo(() => getFunctionName(query), [query]);
     const schema = useMemo(() => fetchSchemaFromMap({
         queryName,

package/dist/convex-cache/core/server-cache/queries/paginated-query.d.ts

@@ -1,5 +1,5 @@
-import { PQ_Query, PQ_Args, PQ_Result, PQ_CachedResult } from "../../types/types/paginated-query";
-import { PQ_ArgsPreloaded } from "../../../adapters/next/types/preloaded";
+import type { PQ_Query, PQ_Args, PQ_Result, PQ_CachedResult } from "../../types/types/paginated-query";
+import type { PQ_ArgsPreloaded } from "../../../adapters/next/types/preloaded";
 export type T_UseCachedPaginatedQueryServer<Q extends PQ_Query> = {
     query: Q;
     args: PQ_Args<Q>;
@@ -12,4 +12,4 @@ export type T_UseCachedPaginatedQueryServer<Q extends PQ_Query> = {
         args: PQ_ArgsPreloaded<Q>;
     }) => void;
 };
-export declare const _useCachedPaginatedQueryServer: <Q extends PQ_Query>({ query, args, options, preloadedData, revalidateCache }: T_UseCachedPaginatedQueryServer<Q>) => PQ_Result<Q>;
+export declare const _useCachedPaginatedQueryServer: <Q extends PQ_Query>({ query, args, options, preloadedData, revalidateCache, }: T_UseCachedPaginatedQueryServer<Q>) => PQ_Result<Q>;

package/dist/convex-cache/core/server-cache/queries/paginated-query.js

@@ -1,7 +1,7 @@
 import { usePaginatedQuery } from "convex/react";
 import { useEffect } from "react";
 import { isDeepEqual } from "@bb-labs/deep-equal";
-export const _useCachedPaginatedQueryServer = ({ query, args, options, preloadedData, revalidateCache }) => {
+export const _useCachedPaginatedQueryServer = ({ query, args, options, preloadedData, revalidateCache, }) => {
     const raw = usePaginatedQuery(query, args, options);
     useEffect(() => {
         if (args === "skip")
@@ -10,7 +10,15 @@ export const _useCachedPaginatedQueryServer = ({ query, args, options, preloaded
             return;
         if (isDeepEqual(preloadedData, raw))
             return;
-        revalidateCache({ query, args: { ...args, paginationOpts: { numItems: options.initialNumItems, cursor: null } } });
+        revalidateCache({
+            query,
+            args: { ...args, paginationOpts: { numItems: options.initialNumItems, cursor: null } },
+        });
     }, [raw]);
-    return raw.status == "LoadingFirstPage" ? { ...(preloadedData ?? { results: [], status: "LoadingFirstPage", isLoading: false }), loadMore: () => { } } : raw;
+    return raw.status == "LoadingFirstPage"
+        ? {
+            ...(preloadedData ?? { results: [], status: "LoadingFirstPage", isLoading: false }),
+            loadMore: () => { },
+        }
+        : raw;
 };

package/dist/convex-cache/core/server-cache/queries/query.d.ts

@@ -1,5 +1,5 @@
-import { Q_Query, Q_Args, Q_Result } from "../../types/types/query";
-import { Q_ArgsPreloaded } from "../../../adapters/next/types/preloaded";
+import type { Q_Query, Q_Args, Q_Result } from "../../types/types/query";
+import type { Q_ArgsPreloaded } from "../../../adapters/next/types/preloaded";
 export type T_UseCachedQueryServer<Q extends Q_Query> = {
     query: Q;
     args: Q_Args<Q>;
@@ -9,4 +9,4 @@ export type T_UseCachedQueryServer<Q extends Q_Query> = {
         args: Q_ArgsPreloaded<Q>;
     }) => void;
 };
-export declare const _useCachedQueryServer: <Q extends Q_Query>({ query, args, preloadedData, revalidateCache }: T_UseCachedQueryServer<Q>) => Q_Result<Q> | undefined;
+export declare const _useCachedQueryServer: <Q extends Q_Query>({ query, args, preloadedData, revalidateCache, }: T_UseCachedQueryServer<Q>) => Q_Result<Q> | undefined;

package/dist/convex-cache/core/server-cache/queries/query.js

@@ -1,7 +1,7 @@
 import { useQuery } from "convex/react";
 import { useEffect } from "react";
 import { isDeepEqual } from "@bb-labs/deep-equal";
-export const _useCachedQueryServer = ({ query, args, preloadedData, revalidateCache }) => {
+export const _useCachedQueryServer = ({ query, args, preloadedData, revalidateCache, }) => {
     const raw = useQuery(query, args);
     useEffect(() => {
         if (args === "skip")

package/dist/convex-cache/core/types/types/paginated-query.d.ts

@@ -1,5 +1,5 @@
 import { ConvexHttpClient } from "convex/browser";
-import { PaginatedQueryReference, PaginatedQueryArgs, UsePaginatedQueryResult, PaginatedQueryItem } from "convex/react";
+import type { PaginatedQueryReference, PaginatedQueryArgs, UsePaginatedQueryResult, PaginatedQueryItem } from "convex/react";
 export type PQ_Query = PaginatedQueryReference;
 export type PQ_Args<Q extends PQ_Query> = PaginatedQueryArgs<Q> | "skip";
 export type PQ_Result<Q extends PQ_Query> = UsePaginatedQueryResult<PaginatedQueryItem<Q>>;

package/dist/convex-cache/core/types/types/query.d.ts

@@ -1,5 +1,5 @@
-import { OptionalRestArgsOrSkip } from "convex/react";
-import { FunctionReference, FunctionReturnType } from "convex/server";
+import type { OptionalRestArgsOrSkip } from "convex/react";
+import type { FunctionReference, FunctionReturnType } from "convex/server";
 export type Q_Query = FunctionReference<"query">;
 export type Q_Args<Q extends Q_Query> = OptionalRestArgsOrSkip<Q>[0];
 export type Q_Result<Q extends Q_Query> = FunctionReturnType<Q>;

package/package.json

@@ -1,23 +1,12 @@
 {
   "name": "@bb-labs/convex-cache",
-  "version": "0.0.1",
-  "description": "A library for caching Convex queries on the client and server",
-  "homepage": "https://github.com/beepbop-labs/convex-cache",
-  "keywords": [
-    "convex-cache",
-    "convex",
-    "react",
-    "nextjs"
-  ],
-  "author": "Beepbop",
-  "license": "MIT",
+  "version": "0.0.3",
   "repository": {
     "type": "git",
-    "url": "https://github.com/beepbop-labs/convex-cache.git"
+    "url": "https://github.com/beepbop-labs/libraries.git"
   },
   "files": [
-    "dist",
-    "README.md"
+    "dist"
   ],
   "type": "module",
   "exports": {
@@ -32,13 +21,16 @@
     "convex-cache": "dist/cli/index.js"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.json",
-    "archive": "rm -rf archive && mkdir -p archive && bun run build && npm pack --pack-destination ./archive/"
+    "build": "bldr",
+    "dev": "bldr -w",
+    "clean": "rm -rf node_modules bun.lock dist"
   },
   "dependencies": {
+    "@bb-labs/bldr": "^0.0.15",
     "@bb-labs/deep-equal": "^0.0.1",
     "@bb-labs/deep-sort": "^0.0.1",
     "@bb-labs/local-db": "^0.0.1",
+    "@bb-labs/tsconfigs": "^0.0.3",
     "commander": "^14.0.2",
     "convex": "^1.29.3",
     "convex-helpers": "^0.1.106",
@@ -53,6 +45,7 @@
   "devDependencies": {
     "@types/node": "^24.10.1",
     "@types/react": "^19.2.7",
+    "tsc-alias": "^1.8.16",
     "typescript": "^5.9.3"
   }
 }