better-convex 0.6.4 → 0.7.0

package/dist/query-context-DGExXZIV.d.ts

@@ -0,0 +1,42 @@
+import { DocumentByName, GenericQueryCtx, TableNamesInDataModel } from "convex/server";
+
+//#region src/orm/query-context.d.ts
+type InferCtxDataModel<TCtx extends GenericQueryCtx<any>> = TCtx extends GenericQueryCtx<infer DataModel> ? DataModel : never;
+type DocByCtx<TCtx extends GenericQueryCtx<any>, TableName extends TableNamesInDataModel<InferCtxDataModel<TCtx>>> = DocumentByName<InferCtxDataModel<TCtx>, TableName>;
+type QueryCtxWithOptionalOrmQueryTable<TCtx extends GenericQueryCtx<any>, TableName extends TableNamesInDataModel<InferCtxDataModel<TCtx>>> = TCtx & {
+  orm?: {
+    query?: { [K in TableName]?: {
+      findFirst?: (...args: any[]) => unknown;
+    } };
+  };
+};
+type QueryCtxWithOrmQueryTable<TCtx extends GenericQueryCtx<any>, TableName extends TableNamesInDataModel<InferCtxDataModel<TCtx>>> = TCtx & {
+  orm: {
+    query: { [K in TableName]-?: {
+      findFirst: (...args: any[]) => unknown;
+    } };
+  };
+};
+type OrmQueryByCtx<TCtx extends GenericQueryCtx<any>> = TCtx extends {
+  orm: {
+    query: infer TQuery;
+  };
+} ? TQuery : never;
+type OrmQueryEntryByCtx<TCtx extends GenericQueryCtx<any>, TableName extends TableNamesInDataModel<InferCtxDataModel<TCtx>>> = TableName extends keyof OrmQueryByCtx<TCtx> ? NonNullable<OrmQueryByCtx<TCtx>[TableName]> : never;
+type HasOrmFindFirstByCtx<TCtx extends GenericQueryCtx<any>, TableName extends TableNamesInDataModel<InferCtxDataModel<TCtx>>> = [OrmQueryEntryByCtx<TCtx, TableName>] extends [never] ? false : OrmQueryEntryByCtx<TCtx, TableName> extends {
+  findFirst: (...args: any[]) => unknown;
+} ? true : false;
+type QueryCtxWithPreferredOrmQueryTable<TCtx extends GenericQueryCtx<any>, TableName extends TableNamesInDataModel<InferCtxDataModel<TCtx>>> = TCtx extends {
+  orm: unknown;
+} ? HasOrmFindFirstByCtx<TCtx, TableName> extends true ? TCtx : never : TCtx;
+type OrmQueryRowByCtx<TCtx extends GenericQueryCtx<any>, TableName extends TableNamesInDataModel<InferCtxDataModel<TCtx>>> = OrmQueryEntryByCtx<TCtx, TableName> extends {
+  _: {
+    baseResult: infer TResult;
+  };
+} ? TResult : never;
+type LookupByIdResultByCtx<TCtx extends GenericQueryCtx<any>, TableName extends TableNamesInDataModel<InferCtxDataModel<TCtx>>> = (TCtx extends {
+  orm: unknown;
+} ? OrmQueryRowByCtx<TCtx, TableName> : DocByCtx<TCtx, TableName>) | null;
+declare function getByIdWithOrmQueryFallback<TCtx extends GenericQueryCtx<any>, TableName extends TableNamesInDataModel<InferCtxDataModel<TCtx>>>(ctx: QueryCtxWithPreferredOrmQueryTable<TCtx, TableName>, tableName: TableName, id: DocByCtx<TCtx, TableName>['_id']): Promise<LookupByIdResultByCtx<TCtx, TableName>>;
+//#endregion
+export { QueryCtxWithPreferredOrmQueryTable as a, QueryCtxWithOrmQueryTable as i, LookupByIdResultByCtx as n, getByIdWithOrmQueryFallback as o, QueryCtxWithOptionalOrmQueryTable as r, DocByCtx as t };

package/dist/react/index.d.ts

@@ -1,6 +1,6 @@
 'use client';
 import { ConvexProvider, ConvexProviderWithAuth as ConvexProviderWithAuth$1, ConvexReactClient, ConvexReactClient as ConvexReactClient$1, ConvexReactClientOptions, Watch, WatchQueryOptions, useConvex } from "convex/react";
-import * as react0 from "react";
+import * as react from "react";
 import { ReactNode } from "react";
 import * as jotai_x0 from "jotai-x";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
@@ -80,7 +80,7 @@ declare function createAuthMutations<T extends AuthClient>(authClient: T): AuthM
 type FetchAccessTokenFn = (args: {
   forceRefreshToken: boolean;
 }) => Promise<string | null>;
-declare const FetchAccessTokenContext: react0.Context<FetchAccessTokenFn | null>;
+declare const FetchAccessTokenContext: react.Context<FetchAccessTokenFn | null>;
 /** Get fetchAccessToken from context (available immediately, no race condition) */
 declare const useFetchAccessToken: () => FetchAccessTokenFn | null;
 type ConvexAuthResult = {
@@ -102,7 +102,7 @@ type AuthStoreState = {
 };
 /** Decode JWT expiration (ms timestamp) from token */
 declare function decodeJwtExp(token: string): number | null;
-declare const AuthProvider: react0.FC<jotai_x0.ProviderProps<{
+declare const AuthProvider: react.FC<jotai_x0.ProviderProps<{
     onMutationUnauthorized: () => void;
     onQueryUnauthorized: (info: {
       queryName: string;
@@ -197,33 +197,33 @@ declare function MaybeAuthenticated({
   children
 }: {
   children: React.ReactNode;
-}): react0.ReactNode;
+}): react.ReactNode;
 /** Render children only when authenticated (server-verified) */
 declare function Authenticated({
   children
 }: {
   children: React.ReactNode;
-}): react0.ReactNode;
+}): react.ReactNode;
 /** Render children only when maybe not auth (optimistic) */
 declare function MaybeUnauthenticated({
   children
 }: {
   children: React.ReactNode;
-}): react0.ReactNode;
+}): react.ReactNode;
 /** Render children only when not authenticated (server-verified) */
 declare function Unauthenticated({
   children
 }: {
   children: React.ReactNode;
-}): react0.ReactNode;
+}): react.ReactNode;
 //#endregion
 //#region src/crpc/transformer.d.ts
 /**
  * Generic transformer contract (mirrors tRPC shape).
  */
 interface DataTransformer {
-  serialize(object: any): any;
   deserialize(object: any): any;
+  serialize(object: any): any;
 }
 /**
  * Separate input/output transformers.
@@ -241,15 +241,17 @@ type DataTransformerOptions = CombinedDataTransformer | DataTransformer;
 interface ConvexQueryClientOptions extends ConvexReactClientOptions {
   /** Auth store for checking auth state in queryFn */
   authStore?: AuthStore;
-  /** TanStack QueryClient. Can also be set later via .connect(queryClient) */
-  queryClient?: QueryClient;
-  /** Custom fetch for SSR. Avoid bundling on client. */
-  serverFetch?: typeof globalThis.fetch;
   /**
    * Opt out of consistent SSR queries for faster performance.
    * Trade-off: queries may return results from different timestamps.
    */
   dangerouslyUseInconsistentQueriesDuringSSR?: boolean;
+  /** TanStack QueryClient. Can also be set later via .connect(queryClient) */
+  queryClient?: QueryClient;
+  /** Custom fetch for SSR. Avoid bundling on client. */
+  serverFetch?: typeof globalThis.fetch;
+  /** Optional payload transformer (always composed with built-in Date support). */
+  transformer?: DataTransformerOptions;
   /**
    * Delay in ms before unsubscribing when a query has no observers.
    * Prevents wasteful unsubscribe/subscribe cycles from React StrictMode
@@ -257,8 +259,6 @@ interface ConvexQueryClientOptions extends ConvexReactClientOptions {
    * @default 3000
    */
   unsubscribeDelay?: number;
-  /** Optional payload transformer (always composed with built-in Date support). */
-  transformer?: DataTransformerOptions;
 }
 /**
  * Bridges TanStack Query with Convex real-time subscriptions.
@@ -466,8 +466,8 @@ type UnsetMarker = {
 //#region src/server/http-types.d.ts
 type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 interface HttpRouteDefinition<TMethod extends HttpMethod = HttpMethod> {
-  path: string;
   method: TMethod;
+  path: string;
   pathParamNames: string[];
   usePathPrefix: boolean;
 }
@@ -497,11 +497,11 @@ interface HttpRouterRecord {
  * Router definition - stores both flat procedures and hierarchical record
  */
 interface HttpRouterDef<TRecord extends HttpRouterRecord> {
-  router: true;
   /** Flat map with dot-notation keys (e.g., "todos.get") for lookup */
   procedures: Record<string, HttpProcedure>;
   /** Hierarchical structure for type inference */
   record: TRecord;
+  router: true;
 }
 /**
  * HTTP Router - like tRPC's BuiltRouter
@@ -541,6 +541,7 @@ type FnMeta$1 = {
   rateLimit?: string;
   type?: 'query' | 'mutation' | 'action';
   limit?: number;
+  [key: string]: unknown;
 };
 /** Metadata for paginated functions (limit is required) */
 type PaginatedFnMeta = Omit<FnMeta$1, 'limit'> & {
@@ -708,7 +709,7 @@ type VanillaAction<T extends FunctionReference<'action'>> = {
  * await client.user.update.mutate({ id, name: 'test' });
  * ```
  */
-type VanillaCRPCClient<TApi> = { [K in keyof TApi]: TApi[K] extends FunctionReference<'query'> ? VanillaQuery<TApi[K]> : TApi[K] extends FunctionReference<'mutation'> ? VanillaMutation<TApi[K]> : TApi[K] extends FunctionReference<'action'> ? VanillaAction<TApi[K]> : TApi[K] extends Record<string, unknown> ? VanillaCRPCClient<TApi[K]> : never };
+type VanillaCRPCClient<TApi> = { [K in keyof TApi as K extends string ? K extends `_${string}` ? never : K : K]: TApi[K] extends FunctionReference<'query'> ? VanillaQuery<TApi[K]> : TApi[K] extends FunctionReference<'mutation'> ? VanillaMutation<TApi[K]> : TApi[K] extends FunctionReference<'action'> ? VanillaAction<TApi[K]> : TApi[K] extends Record<string, unknown> ? VanillaCRPCClient<TApi[K]> : never };
 /**
  * Recursively decorates all procedures in a Convex API object.
  *
@@ -728,7 +729,7 @@ type VanillaCRPCClient<TApi> = { [K in keyof TApi]: TApi[K] extends FunctionRefe
  */
 /** Check if a type has cursor key (pagination detection) */
 type IsPaginated<T> = 'cursor' extends keyof T ? true : false;
-type CRPCClient<TApi> = { [K in keyof TApi]: TApi[K] extends FunctionReference<'query'> ? IsPaginated<FunctionArgs<TApi[K]>> extends true ? DecorateQuery<TApi[K]> & DecorateInfiniteQuery<TApi[K]> : DecorateQuery<TApi[K]> : TApi[K] extends FunctionReference<'mutation'> ? DecorateMutation<TApi[K]> : TApi[K] extends FunctionReference<'action'> ? DecorateAction<TApi[K]> : TApi[K] extends Record<string, unknown> ? CRPCClient<TApi[K]> : never };
+type CRPCClient<TApi> = { [K in keyof TApi as K extends string ? K extends `_${string}` ? never : K : K]: TApi[K] extends FunctionReference<'query'> ? IsPaginated<FunctionArgs<TApi[K]>> extends true ? DecorateQuery<TApi[K]> & DecorateInfiniteQuery<TApi[K]> : DecorateQuery<TApi[K]> : TApi[K] extends FunctionReference<'mutation'> ? DecorateMutation<TApi[K]> : TApi[K] extends FunctionReference<'action'> ? DecorateAction<TApi[K]> : TApi[K] extends Record<string, unknown> ? CRPCClient<TApi[K]> : never };
 //#endregion
 //#region src/react/http-proxy.d.ts
 type HttpRouteInfo = {
@@ -865,8 +866,8 @@ type HttpCRPCClientFromRouter<TRouter extends CRPCHttpRouter<any>> = HttpCRPCCli
 interface HttpProxyOptions<TRoutes extends HttpRouteMap> {
   /** Base URL for the Convex HTTP API (e.g., https://your-site.convex.site) */
   convexSiteUrl: string;
-  /** Runtime route definitions (from codegen httpRoutes) */
-  routes: TRoutes;
+  /** Custom fetch function (defaults to global fetch) */
+  fetch?: typeof fetch;
   /** Default headers or async function returning headers (for auth tokens) */
   headers?: {
     [key: string]: string | undefined;
@@ -875,10 +876,10 @@ interface HttpProxyOptions<TRoutes extends HttpRouteMap> {
   } | Promise<{
     [key: string]: string | undefined;
   }>);
-  /** Custom fetch function (defaults to global fetch) */
-  fetch?: typeof fetch;
   /** Error handler called on HTTP errors */
   onError?: (error: HttpClientError) => void;
+  /** Runtime route definitions (from codegen httpRoutes) */
+  routes: TRoutes;
   /** Optional payload transformer (always composed with built-in Date support). */
   transformer?: DataTransformerOptions;
 }
@@ -930,8 +931,7 @@ type CRPCHttpOptions = {
   onError?: (error: HttpClientError) => void;
 };
 type CreateCRPCContextOptions<TApi> = {
-  api: TApi;
-  meta: Meta; /** Optional payload transformer (always composed with built-in Date support). */
+  api: TApi; /** Optional payload transformer (always composed with built-in Date support). */
   transformer?: DataTransformerOptions;
 } & Partial<CRPCHttpOptions>;
 /**
@@ -944,23 +944,18 @@ type ExtractHttpRouter<TApi> = TApi extends {
 /**
  * Create CRPC context, provider, and hooks for a Convex API.
  *
- * @param options - Configuration object containing api, meta, and optional HTTP settings
+ * @param options - Configuration object containing api and optional HTTP settings
  * @returns Object with CRPCProvider, useCRPC, and useCRPCClient
  *
  * @example
  * ```tsx
  * // lib/crpc.ts
  * import { api } from '@convex/api';
- * import { meta } from '@convex/meta';
  * import { createCRPCContext } from 'better-convex/react';
  *
- * // Without HTTP endpoints
- * export const { useCRPC } = createCRPCContext({ api, meta });
- *
- * // With HTTP endpoints (Api = Api & { http?: typeof appRouter })
- * export const { useCRPC } = createCRPCContext<Api>({
+ * // Works for both regular Convex functions and generated HTTP router types
+ * export const { useCRPC } = createCRPCContext({
  *   api,
- *   meta,
  *   convexSiteUrl: process.env.NEXT_PUBLIC_CONVEX_SITE_URL!,
  * });
  *
@@ -1000,7 +995,7 @@ type FnMeta = {
 };
 /** Metadata for all functions in a module */
 type ModuleMeta = Record<string, FnMeta>;
-/** Metadata for all modules - from generated `@convex/meta` */
+/** Metadata for all modules - from generated `@convex/api` */
 type CallerMeta = Record<string, ModuleMeta>;
 //#endregion
 //#region src/react/proxy.d.ts
@@ -1017,9 +1012,10 @@ type CallerMeta = Record<string, ModuleMeta>;
  * @example
  * ```tsx
  * import { api } from '@convex/api';
- * import { meta } from '@convex/meta';
  *
- * const crpc = createCRPCOptionsProxy(api, meta);
+ * // Usually you should use createCRPCContext({ api }) instead.
+ * // createCRPCOptionsProxy is a low-level helper.
+ * const crpc = createCRPCOptionsProxy(api, {} as any);
  *
  * function MyComponent() {
  *   const { data } = useQuery(crpc.user.get.queryOptions({ id }));

package/dist/react/index.js

@@ -1,5 +1,5 @@
 'use client';
-import { S as isCRPCClientError, _ as useIsAuth, a as FetchAccessTokenContext, b as CRPCClientError, c as Unauthenticated, d as useAuthGuard, f as useAuthState, g as useFetchAccessToken, h as useConvexAuthBridge, i as ConvexProviderWithAuth, l as decodeJwtExp, m as useAuthValue, n as Authenticated, o as MaybeAuthenticated, p as useAuthStore, r as ConvexAuthBridge, s as MaybeUnauthenticated, t as AuthProvider, u as useAuth, v as useMaybeAuth, y as useSafeConvexAuth } from "../auth-store-DHapqI5u.js";
+import { S as isCRPCClientError, _ as useIsAuth, a as FetchAccessTokenContext, b as CRPCClientError, c as Unauthenticated, d as useAuthGuard, f as useAuthState, g as useFetchAccessToken, h as useConvexAuthBridge, i as ConvexProviderWithAuth, l as decodeJwtExp, m as useAuthValue, n as Authenticated, o as MaybeAuthenticated, p as useAuthStore, r as ConvexAuthBridge, s as MaybeUnauthenticated, t as AuthProvider, u as useAuth, v as useMaybeAuth, x as defaultIsUnauthorized, y as useSafeConvexAuth } from "../auth-store-DHapqI5u.js";
 import { c } from "react/compiler-runtime";
 import { ConvexProvider, ConvexReactClient, ConvexReactClient as ConvexReactClient$1, useAction, useConvex, useMutation } from "convex/react";
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
@@ -9,6 +9,122 @@ import { getFunctionName } from "convex/server";
 import { ConvexHttpClient } from "convex/browser";
 import { convexToJson } from "convex/values";
 
+//#region src/shared/meta-utils.ts
+const metaCache = /* @__PURE__ */ new WeakMap();
+const nonMetaLeafKeys = new Set(["functionRef", "ref"]);
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isFunctionType(value) {
+	return value === "query" || value === "mutation" || value === "action";
+}
+function isMetaScalar(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function extractLeafMeta(value) {
+	const type = value.type;
+	if (!isFunctionType(type)) return;
+	const result = { type };
+	for (const [key, entry] of Object.entries(value)) {
+		if (key === "type" || nonMetaLeafKeys.has(key) || key.startsWith("_")) continue;
+		if (entry === void 0) continue;
+		if (isMetaScalar(entry)) result[key] = entry;
+	}
+	return result;
+}
+function getHttpRoutes(api) {
+	const routes = api._http;
+	if (!isRecord(routes)) return;
+	const normalized = {};
+	for (const [routeKey, routeValue] of Object.entries(routes)) {
+		if (!isRecord(routeValue)) continue;
+		const routePath = routeValue.path;
+		const routeMethod = routeValue.method;
+		if (typeof routePath === "string" && typeof routeMethod === "string") normalized[routeKey] = {
+			path: routePath,
+			method: routeMethod
+		};
+	}
+	return normalized;
+}
+/**
+* Build a metadata index from merged API leaves.
+* Supports both generated `api` objects and plain metadata fixtures.
+*/
+function buildMetaIndex(api) {
+	const cached = metaCache.get(api);
+	if (cached) return cached;
+	const meta = {};
+	const httpRoutes = getHttpRoutes(api);
+	if (httpRoutes) meta._http = httpRoutes;
+	const walk = (node, path) => {
+		for (const [key, value] of Object.entries(node)) {
+			if (key.startsWith("_")) continue;
+			if (!isRecord(value)) continue;
+			const leafMeta = extractLeafMeta(value);
+			if (leafMeta) {
+				if (path.length === 0) continue;
+				const namespace = path.join("/");
+				meta[namespace] ??= {};
+				meta[namespace][key] = leafMeta;
+				continue;
+			}
+			walk(value, [...path, key]);
+		}
+	};
+	walk(api, []);
+	metaCache.set(api, meta);
+	return meta;
+}
+/**
+* Get a function reference from the API object by traversing the path.
+*/
+function getFuncRef(api, path) {
+	let current = api;
+	for (const key of path) if (current && typeof current === "object") {
+		const next = current[key];
+		if (next === void 0) throw new Error(`Invalid path: ${path.join(".")}`);
+		current = next;
+	} else throw new Error(`Invalid path: ${path.join(".")}`);
+	if (current && typeof current === "object") {
+		const maybeFunctionRef = current.functionRef;
+		if (maybeFunctionRef && typeof maybeFunctionRef === "object") return maybeFunctionRef;
+	}
+	if (!current || typeof current !== "object") throw new Error(`Invalid function reference at path: ${path.join(".")}`);
+	return current;
+}
+/**
+* Get function type from meta using path.
+* Supports nested paths like ['items', 'queries', 'list'] → namespace='items/queries', fn='list'
+*
+* @param path - Path segments like ['todos', 'create'] or ['items', 'queries', 'list']
+* @param meta - The meta object from codegen
+* @returns Function type or 'query' as default
+*/
+function getFunctionType(path, source) {
+	if (path.length < 2) return "query";
+	const meta = buildMetaIndex(source);
+	const fnName = path.at(-1);
+	const fnType = meta[path.slice(0, -1).join("/")]?.[fnName]?.type;
+	if (fnType === "query" || fnType === "mutation" || fnType === "action") return fnType;
+	return "query";
+}
+/**
+* Get function metadata from meta using path.
+* Supports nested paths like ['items', 'queries', 'list'] → namespace='items/queries', fn='list'
+*
+* @param path - Path segments like ['todos', 'create'] or ['items', 'queries', 'list']
+* @param meta - The meta object from codegen
+* @returns Function metadata or undefined
+*/
+function getFunctionMeta(path, source) {
+	if (path.length < 2) return;
+	const meta = buildMetaIndex(source);
+	const fnName = path.at(-1);
+	return meta[path.slice(0, -1).join("/")]?.[fnName];
+}
+
+//#endregion
 //#region src/crpc/http-types.ts
 /** HTTP client error */
 var HttpClientError = class extends Error {
@@ -578,46 +694,6 @@ function convexInfiniteQueryOptions(funcRef, args, opts = {}, meta) {
 /** Symbol key for attaching FunctionReference to options (non-serializable) */
 const FUNC_REF_SYMBOL = Symbol.for("convex.funcRef");
 
-//#endregion
-//#region src/shared/meta-utils.ts
-/**
-* Get a function reference from the API object by traversing the path.
-*/
-function getFuncRef(api, path) {
-	let current = api;
-	for (const key of path) if (current && typeof current === "object") current = current[key];
-	else throw new Error(`Invalid path: ${path.join(".")}`);
-	return current;
-}
-/**
-* Get function type from meta using path.
-* Supports nested paths like ['items', 'queries', 'list'] → namespace='items/queries', fn='list'
-*
-* @param path - Path segments like ['todos', 'create'] or ['items', 'queries', 'list']
-* @param meta - The meta object from codegen
-* @returns Function type or 'query' as default
-*/
-function getFunctionType(path, meta) {
-	if (path.length < 2) return "query";
-	const fnName = path.at(-1);
-	const fnType = meta[path.slice(0, -1).join("/")]?.[fnName]?.type;
-	if (fnType === "query" || fnType === "mutation" || fnType === "action") return fnType;
-	return "query";
-}
-/**
-* Get function metadata from meta using path.
-* Supports nested paths like ['items', 'queries', 'list'] → namespace='items/queries', fn='list'
-*
-* @param path - Path segments like ['todos', 'create'] or ['items', 'queries', 'list']
-* @param meta - The meta object from codegen
-* @returns Function metadata or undefined
-*/
-function getFunctionMeta(path, meta) {
-	if (path.length < 2) return;
-	const fnName = path.at(-1);
-	return meta[path.slice(0, -1).join("/")]?.[fnName];
-}
-
 //#endregion
 //#region src/internal/auth.ts
 /** Get auth type from meta for a function */
@@ -1221,9 +1297,10 @@ function createRecursiveProxy(api, path, meta, transformer) {
 * @example
 * ```tsx
 * import { api } from '@convex/api';
-* import { meta } from '@convex/meta';
 *
-* const crpc = createCRPCOptionsProxy(api, meta);
+* // Usually you should use createCRPCContext({ api }) instead.
+* // createCRPCOptionsProxy is a low-level helper.
+* const crpc = createCRPCOptionsProxy(api, {} as any);
 *
 * function MyComponent() {
 *   const { data } = useQuery(crpc.user.get.queryOptions({ id }));
@@ -1325,23 +1402,18 @@ function useFnMeta() {
 /**
 * Create CRPC context, provider, and hooks for a Convex API.
 *
-* @param options - Configuration object containing api, meta, and optional HTTP settings
+* @param options - Configuration object containing api and optional HTTP settings
 * @returns Object with CRPCProvider, useCRPC, and useCRPCClient
 *
 * @example
 * ```tsx
 * // lib/crpc.ts
 * import { api } from '@convex/api';
-* import { meta } from '@convex/meta';
 * import { createCRPCContext } from 'better-convex/react';
 *
-* // Without HTTP endpoints
-* export const { useCRPC } = createCRPCContext({ api, meta });
-*
-* // With HTTP endpoints (Api = Api & { http?: typeof appRouter })
-* export const { useCRPC } = createCRPCContext<Api>({
+* // Works for both regular Convex functions and generated HTTP router types
+* export const { useCRPC } = createCRPCContext({
 *   api,
-*   meta,
 *   convexSiteUrl: process.env.NEXT_PUBLIC_CONVEX_SITE_URL!,
 * });
 *
@@ -1356,7 +1428,8 @@ function useFnMeta() {
 * ```
 */
 function createCRPCContext(options) {
-	const { api, meta, ...httpOptions } = options;
+	const { api, ...httpOptions } = options;
+	const meta = buildMetaIndex(api);
 	const CRPCProxyContext = createContext(null);
 	const VanillaClientContext = createContext(null);
 	const HttpProxyContext = createContext(void 0);
@@ -2171,9 +2244,11 @@ var ConvexQueryClient = class {
 			if (isConvexQuery(queryKey)) {
 				const [, funcName, args] = queryKey;
 				const wireArgs = this.transformer.input.serialize(args);
+				const skipUnauth = meta?.skipUnauth ?? false;
 				if (meta?.authType === "required" && !isServer && this.authStore) {
 					const authState = this.getAuthState();
 					if (authState && !authState.isLoading && !authState.isAuthenticated) {
+						if (skipUnauth) return null;
 						authState.onUnauthorized({ queryName: funcName });
 						throw new CRPCClientError({
 							code: "UNAUTHORIZED",
@@ -2181,18 +2256,25 @@ var ConvexQueryClient = class {
 						});
 					}
 				}
-				if (isServer) {
-					if (this.ssrQueryMode === "consistent") return this.transformer.output.deserialize(await this.serverHttpClient.consistentQuery(funcName, wireArgs));
-					return this.transformer.output.deserialize(await this.serverHttpClient.query(funcName, wireArgs));
+				try {
+					if (isServer) {
+						if (this.ssrQueryMode === "consistent") return this.transformer.output.deserialize(await this.serverHttpClient.consistentQuery(funcName, wireArgs));
+						return this.transformer.output.deserialize(await this.serverHttpClient.query(funcName, wireArgs));
+					}
+					return this.transformer.output.deserialize(await this.convexClient.query(funcName, wireArgs));
+				} catch (error) {
+					if (skipUnauth && defaultIsUnauthorized(error)) return null;
+					throw error;
 				}
-				return this.transformer.output.deserialize(await this.convexClient.query(funcName, wireArgs));
 			}
 			if (isConvexAction(queryKey)) {
 				const [, funcName, args] = queryKey;
 				const wireArgs = this.transformer.input.serialize(args);
+				const skipUnauth = meta?.skipUnauth ?? false;
 				if (meta?.authType === "required" && !isServer && this.authStore) {
 					const authState = this.getAuthState();
 					if (authState && !authState.isLoading && !authState.isAuthenticated) {
+						if (skipUnauth) return null;
 						authState.onUnauthorized({ queryName: funcName });
 						throw new CRPCClientError({
 							code: "UNAUTHORIZED",
@@ -2200,8 +2282,13 @@ var ConvexQueryClient = class {
 						});
 					}
 				}
-				if (isServer) return this.transformer.output.deserialize(await this.serverHttpClient.action(funcName, wireArgs));
-				return this.transformer.output.deserialize(await this.convexClient.action(funcName, wireArgs));
+				try {
+					if (isServer) return this.transformer.output.deserialize(await this.serverHttpClient.action(funcName, wireArgs));
+					return this.transformer.output.deserialize(await this.convexClient.action(funcName, wireArgs));
+				} catch (error) {
+					if (skipUnauth && defaultIsUnauthorized(error)) return null;
+					throw error;
+				}
 			}
 			return otherFetch(context);
 		};

package/dist/rsc/index.d.ts

@@ -1,6 +1,6 @@
-import { C as HttpProcedure, G as DataTransformerOptions, V as UnsetMarker, d as CRPCHttpRouter, p as HttpRouterRecord } from "../http-types-BRLY10NX.js";
-import { o as Simplify, r as DistributiveOmit } from "../types-jftzhhuc.js";
-import { S as Meta, n as CRPCClient } from "../types-o-5rYcTr.js";
+import { o as Simplify, r as DistributiveOmit } from "../types-DwGkkq2s.js";
+import { C as HttpProcedure, G as DataTransformerOptions, V as UnsetMarker, d as CRPCHttpRouter, p as HttpRouterRecord } from "../http-types-BCf2wCgp.js";
+import { n as CRPCClient } from "../types-CIBGEYXq.js";
 import { DefaultError, QueryFilters, UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
 import { z } from "zod";
 
@@ -110,7 +110,6 @@ type HttpCRPCClientFromRouter<TRouter extends CRPCHttpRouter<any>> = HttpCRPCCli
 //#region src/rsc/proxy-server.d.ts
 type CreateServerCRPCProxyOptions<TApi> = {
   api: TApi;
-  meta: Meta;
 };
 /**
  * Extract HTTP router from TApi['http'] if present (optional).
@@ -137,11 +136,9 @@ type ServerCRPCClient<TApi extends Record<string, unknown>> = ExtractHttpRouter<
  * ```tsx
  * // src/lib/convex/rsc.tsx
  * import { api } from '@convex/api';
- * import { meta } from '@convex/meta';
- * import type { Api } from '@convex/types';
  *
  * // Proxy just builds query options - no auth config here
- * export const crpc = createServerCRPCProxy<Api>({ api, meta });
+ * export const crpc = createServerCRPCProxy({ api });
  *
  * // Auth + execution config in QueryClient
  * const queryClient = new QueryClient({

package/dist/rsc/index.js

@@ -1,8 +1,9 @@
-import { i as decodeWire, s as getTransformer } from "../transformer-CTNSPjwp.js";
-import { n as getFunctionMeta, t as getFuncRef } from "../meta-utils-DCpLSBWB.js";
-import { n as convexInfiniteQueryOptions, r as convexQuery } from "../query-options-BL1Q0X7q.js";
-import { getFunctionName } from "convex/server";
+import { n as defaultIsUnauthorized } from "../error-Be4OcwwD.js";
+import { n as getFuncRef, r as getFunctionMeta, t as buildMetaIndex } from "../meta-utils-DDVYp9Xf.js";
+import { i as decodeWire, s as getTransformer } from "../transformer-Dh0w2py0.js";
+import { n as convexInfiniteQueryOptions, r as convexQuery } from "../query-options-B0c1b6pZ.js";
 import { convexToJson } from "convex/values";
+import { getFunctionName } from "convex/server";
 import { fetchAction, fetchQuery } from "convex/nextjs";
 import { hashKey } from "@tanstack/react-query";
 
@@ -105,11 +106,9 @@ function createRecursiveProxy(api, path, meta) {
 * ```tsx
 * // src/lib/convex/rsc.tsx
 * import { api } from '@convex/api';
-* import { meta } from '@convex/meta';
-* import type { Api } from '@convex/types';
 *
 * // Proxy just builds query options - no auth config here
-* export const crpc = createServerCRPCProxy<Api>({ api, meta });
+* export const crpc = createServerCRPCProxy({ api });
 *
 * // Auth + execution config in QueryClient
 * const queryClient = new QueryClient({
@@ -125,8 +124,8 @@ function createRecursiveProxy(api, path, meta) {
 * ```
 */
 function createServerCRPCProxy(options) {
-	const { api, meta } = options;
-	return createRecursiveProxy(api, [], meta);
+	const { api } = options;
+	return createRecursiveProxy(api, [], buildMetaIndex(api));
 }
 
 //#endregion
@@ -219,7 +218,12 @@ function getServerQueryClientOptions({ getToken, convexSiteUrl, transformer: tra
 			const authRequired = queryMeta?.authType === "required";
 			if (!token && (skipUnauth || authRequired)) return null;
 			const opts = token ? { token } : void 0;
-			return transformer.output.deserialize(type === "convexQuery" ? await fetchQuery(funcRef, wireArgs, opts) : await fetchAction(funcRef, wireArgs, opts));
+			try {
+				return transformer.output.deserialize(type === "convexQuery" ? await fetchQuery(funcRef, wireArgs, opts) : await fetchAction(funcRef, wireArgs, opts));
+			} catch (error) {
+				if ((skipUnauth || authRequired) && defaultIsUnauthorized(error)) return null;
+				throw error;
+			}
 		},
 		queryKeyHashFn: createHashFn()
 	} };