kitcn 0.0.1 → 0.12.1

package/dist/auth/nextjs/index.d.ts

@@ -0,0 +1,50 @@
+import { I as ConvexContext, R as LazyCaller } from "../../procedure-caller-DtxLmGwA.js";
+import { GetTokenOptions } from "@convex-dev/better-auth/utils";
+
+//#region src/auth-nextjs/index.d.ts
+/** Auth options for server-side calls. */
+type AuthOptions = {
+  /** Enable/disable JWT caching. Default: true */jwtCache?: boolean; /** Custom function to detect UNAUTHORIZED errors. Default checks code property. */
+  isUnauthorized?: (error: unknown) => boolean; /** Expiration tolerance in seconds. */
+  expirationToleranceSeconds?: number;
+};
+type ConvexBetterAuthOptions<TApi> = Omit<GetTokenOptions, 'jwtCache'> & {
+  api: TApi;
+  convexSiteUrl: string;
+  convexUrl?: string; /** Auth options. JWT caching is enabled by default (set `auth.jwtCache: false` to disable). */
+  auth?: AuthOptions;
+};
+/**
+ * Create Convex caller factory with Better Auth integration for Next.js.
+ *
+ * @example
+ * ```ts
+ * // server.ts
+ * export const { createContext, createCaller, handler } = convexBetterAuth({
+ *   api,
+ *   convexSiteUrl: env.NEXT_PUBLIC_CONVEX_SITE_URL,
+ * }); // JWT caching enabled by default
+ *
+ * // rsc.tsx
+ * const createRSCContext = cache(async () => {
+ *   const heads = await headers();
+ *   return createContext({ headers: heads });
+ * });
+ * export const caller = createCaller(createRSCContext);
+ *
+ * // app/page.tsx - single call!
+ * const posts = await caller.posts.list();
+ * ```
+ */
+declare function convexBetterAuth<TApi extends Record<string, unknown>>(opts: ConvexBetterAuthOptions<TApi>): {
+  createCaller: (ctxFn: () => Promise<ConvexContext<TApi>>) => LazyCaller<TApi>;
+  createContext: (reqOpts: {
+    headers: Headers;
+  }) => Promise<ConvexContext<TApi>>;
+  handler: {
+    GET: (request: Request) => Promise<Response>;
+    POST: (request: Request) => Promise<Response>;
+  };
+};
+//#endregion
+export { convexBetterAuth };

package/dist/auth/nextjs/index.js

@@ -0,0 +1,81 @@
+import { n as defaultIsUnauthorized } from "../../error-BZEnI7Sq.js";
+import { t as createCallerFactory } from "../../caller-factory-cTXNvYdz.js";
+import { getToken } from "@convex-dev/better-auth/utils";
+
+//#region src/auth-nextjs/index.ts
+/** biome-ignore-all lint/suspicious/noExplicitAny: lib */
+/**
+* Next.js + Better Auth wrapper for Convex caller factory.
+* Uses @convex-dev/better-auth for token management.
+*/
+const handler = (request, siteUrl) => {
+	const requestUrl = new URL(request.url);
+	const nextUrl = `${siteUrl}${requestUrl.pathname}${requestUrl.search}`;
+	const newRequest = new Request(nextUrl, request);
+	newRequest.headers.set("accept-encoding", "application/json");
+	newRequest.headers.set("host", new URL(siteUrl).host);
+	return fetch(newRequest, {
+		method: request.method,
+		redirect: "manual"
+	});
+};
+const nextJsHandler = (siteUrl) => ({
+	GET: (request) => handler(request, siteUrl),
+	POST: (request) => handler(request, siteUrl)
+});
+/**
+* Create Convex caller factory with Better Auth integration for Next.js.
+*
+* @example
+* ```ts
+* // server.ts
+* export const { createContext, createCaller, handler } = convexBetterAuth({
+*   api,
+*   convexSiteUrl: env.NEXT_PUBLIC_CONVEX_SITE_URL,
+* }); // JWT caching enabled by default
+*
+* // rsc.tsx
+* const createRSCContext = cache(async () => {
+*   const heads = await headers();
+*   return createContext({ headers: heads });
+* });
+* export const caller = createCaller(createRSCContext);
+*
+* // app/page.tsx - single call!
+* const posts = await caller.posts.list();
+* ```
+*/
+function convexBetterAuth(opts) {
+	const auth = opts.auth ?? {};
+	const jwtCacheEnabled = auth.jwtCache !== false;
+	const { createContext, createCaller } = createCallerFactory({
+		api: opts.api,
+		auth: jwtCacheEnabled ? {
+			getToken: (siteUrl, headers, getTokenOpts) => {
+				const mutableHeaders = new Headers(headers);
+				mutableHeaders.delete("content-length");
+				mutableHeaders.delete("transfer-encoding");
+				mutableHeaders.set("accept-encoding", "identity");
+				return getToken(siteUrl, mutableHeaders, {
+					...getTokenOpts,
+					jwtCache: {
+						enabled: true,
+						expirationToleranceSeconds: auth.expirationToleranceSeconds,
+						isAuthError: auth.isUnauthorized ?? defaultIsUnauthorized
+					}
+				});
+			},
+			isUnauthorized: auth.isUnauthorized ?? defaultIsUnauthorized
+		} : void 0,
+		convexSiteUrl: opts.convexSiteUrl,
+		convexUrl: opts.convexUrl
+	});
+	return {
+		createCaller,
+		createContext,
+		handler: nextJsHandler(opts.convexSiteUrl)
+	};
+}
+
+//#endregion
+export { convexBetterAuth };

package/dist/auth-store-Cljlmdmi.js

@@ -0,0 +1,197 @@
+'use client';
+import { ConvexProviderWithAuth, useConvexAuth } from "convex/react";
+import { createContext, useContext } from "react";
+import { createAtomStore } from "jotai-x";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/crpc/error.ts
+/**
+* Client-side CRPC error.
+* Mirrors backend CRPCError pattern with typed error codes.
+*/
+var CRPCClientError = class extends Error {
+	name = "CRPCClientError";
+	code;
+	functionName;
+	constructor(opts) {
+		super(opts.message ?? `${opts.code}: ${opts.functionName}`);
+		this.code = opts.code;
+		this.functionName = opts.functionName;
+	}
+};
+/** Type guard for CRPCClientError */
+const isCRPCClientError = (error) => error instanceof CRPCClientError;
+/** Default unauthorized detection - checks UNAUTHORIZED code */
+const defaultIsUnauthorized = (error) => {
+	if (!error || typeof error !== "object") return false;
+	if ("data" in error) {
+		const data = error.data;
+		if (data && typeof data === "object" && "code" in data) return data.code === "UNAUTHORIZED";
+	}
+	if ("code" in error) return error.code === "UNAUTHORIZED";
+	return false;
+};
+
+//#endregion
+//#region src/react/auth-store.tsx
+/**
+* Auth Store - Generic auth state management with jotai-x
+*
+* Provides token storage and auth callback configuration.
+* App configures handlers, lib hooks consume state.
+*/
+const FetchAccessTokenContext = createContext(null);
+/** Get fetchAccessToken from context (available immediately, no race condition) */
+const useFetchAccessToken = () => useContext(FetchAccessTokenContext);
+/**
+* Context that holds auth result from ConvexAuthBridge.
+* Allows @convex-dev/auth users to use skipUnauth queries without better-auth.
+*/
+const ConvexAuthBridgeContext = createContext(null);
+/** Get auth from bridge context (null if no bridge configured) */
+const useConvexAuthBridge = () => useContext(ConvexAuthBridgeContext);
+const AUTH_SESSION_SYNC_GRACE_MS = 1e4;
+const isSessionSyncGraceActive = (sessionSyncGraceUntil) => typeof sessionSyncGraceUntil === "number" && sessionSyncGraceUntil > Date.now();
+/** Decode JWT expiration (ms timestamp) from token */
+function decodeJwtExp(token) {
+	try {
+		const payload = JSON.parse(atob(token.split(".")[1]));
+		return payload.exp ? payload.exp * 1e3 : null;
+	} catch {
+		return null;
+	}
+}
+const { AuthProvider, useAuthStore, useAuthState, useAuthValue } = createAtomStore({
+	onMutationUnauthorized: () => {
+		throw new CRPCClientError({
+			code: "UNAUTHORIZED",
+			functionName: "mutation"
+		});
+	},
+	onQueryUnauthorized: () => {},
+	isUnauthorized: defaultIsUnauthorized,
+	token: null,
+	expiresAt: null,
+	isLoading: true,
+	isAuthenticated: false,
+	sessionSyncGraceUntil: null
+}, {
+	name: "auth",
+	suppressWarnings: true
+});
+/**
+* Safe wrapper around useConvexAuth that doesn't throw when used outside auth provider.
+* Returns { isAuthenticated: false, isLoading: false } when no auth provider.
+*
+* Supports both:
+* - better-auth users (via AuthProvider)
+* - @convex-dev/auth users (via ConvexAuthBridge)
+*/
+function useSafeConvexAuth() {
+	const authStore = useAuthStore();
+	const bridgeAuth = useConvexAuthBridge();
+	if (authStore.store) return useConvexAuth();
+	if (bridgeAuth !== null) return bridgeAuth;
+	return {
+		isAuthenticated: false,
+		isLoading: false
+	};
+}
+/**
+* Internal bridge component. Use `ConvexProviderWithAuth` instead.
+* @internal
+*/
+function ConvexAuthBridge({ children }) {
+	const auth = useConvexAuth();
+	return /* @__PURE__ */ jsx(ConvexAuthBridgeContext.Provider, {
+		value: auth,
+		children
+	});
+}
+/**
+* Convex provider with auth bridge for @convex-dev/auth users.
+* Automatically wraps children with ConvexAuthBridge.
+*
+* @example
+* ```tsx
+* import { ConvexProviderWithAuth } from 'kitcn/react';
+*
+* <ConvexProviderWithAuth client={convex} useAuth={useAuthFromConvexDev}>
+*   <App />
+* </ConvexProviderWithAuth>
+* ```
+*/
+function ConvexProviderWithAuth$1({ children, ...props }) {
+	return /* @__PURE__ */ jsx(ConvexProviderWithAuth, {
+		...props,
+		children: /* @__PURE__ */ jsx(ConvexAuthBridge, { children })
+	});
+}
+const useAuth = () => {
+	const authStore = useAuthStore();
+	const bridgeAuth = useConvexAuthBridge();
+	if (authStore.store) {
+		if (typeof window === "undefined") return {
+			hasSession: !!authStore.get("token"),
+			isAuthenticated: false,
+			isLoading: true
+		};
+		const { isLoading, isAuthenticated } = useConvexAuth();
+		return {
+			hasSession: !!useAuthValue("token"),
+			isAuthenticated,
+			isLoading
+		};
+	}
+	if (bridgeAuth !== null) return {
+		hasSession: false,
+		isAuthenticated: bridgeAuth.isAuthenticated,
+		isLoading: bridgeAuth.isLoading
+	};
+	return {
+		hasSession: false,
+		isAuthenticated: false,
+		isLoading: false
+	};
+};
+/** Check if user maybe has auth (optimistic, has token) */
+const useMaybeAuth = () => {
+	const { hasSession } = useAuth();
+	return hasSession;
+};
+/** Check if user is authenticated (server-verified) */
+const useIsAuth = () => {
+	const { isAuthenticated } = useAuth();
+	return isAuthenticated;
+};
+const useAuthGuard = () => {
+	const { isAuthenticated } = useSafeConvexAuth();
+	const onMutationUnauthorized = useAuthValue("onMutationUnauthorized");
+	return (callback) => {
+		if (!isAuthenticated) {
+			onMutationUnauthorized();
+			return true;
+		}
+		return callback ? void callback() : false;
+	};
+};
+/** Render children only when maybe has auth (optimistic) */
+function MaybeAuthenticated({ children }) {
+	return useMaybeAuth() ? children : null;
+}
+/** Render children only when authenticated (server-verified) */
+function Authenticated({ children }) {
+	return useIsAuth() ? children : null;
+}
+/** Render children only when maybe not auth (optimistic) */
+function MaybeUnauthenticated({ children }) {
+	return useMaybeAuth() ? null : children;
+}
+/** Render children only when not authenticated (server-verified) */
+function Unauthenticated({ children }) {
+	const { isAuthenticated, isLoading } = useAuth();
+	return isLoading || isAuthenticated ? null : children;
+}
+
+//#endregion
+export { defaultIsUnauthorized as C, CRPCClientError as S, useConvexAuthBridge as _, ConvexProviderWithAuth$1 as a, useMaybeAuth as b, MaybeUnauthenticated as c, isSessionSyncGraceActive as d, useAuth as f, useAuthValue as g, useAuthStore as h, ConvexAuthBridge as i, Unauthenticated as l, useAuthState as m, AuthProvider as n, FetchAccessTokenContext as o, useAuthGuard as p, Authenticated as r, MaybeAuthenticated as s, AUTH_SESSION_SYNC_GRACE_MS as t, decodeJwtExp as u, useFetchAccessToken as v, isCRPCClientError as w, useSafeConvexAuth as x, useIsAuth as y };