better-convex 0.2.1 → 0.3.0

package/dist/auth/index.d.ts

@@ -1,10 +1,11 @@
-import * as better_auth_adapters0 from "better-auth/adapters";
+import * as better_auth_adapters1 from "better-auth/adapters";
 import { DBAdapterDebugLogOption } from "better-auth/adapters";
 import { BetterAuthDBSchema } from "better-auth/db";
-import * as convex_server0 from "convex/server";
-import { DocumentByName, FunctionReference, GenericDataModel, GenericMutationCtx, GenericQueryCtx, GenericSchema, HttpRouter, IdField, PaginationOptions, PaginationResult, SchemaDefinition, SystemFields, TableNamesInDataModel, internalMutationGeneric } from "convex/server";
+import * as convex_server24 from "convex/server";
+import { DocumentByName, FunctionReference, GenericDataModel, GenericMutationCtx, GenericQueryCtx, GenericSchema, IdField, PaginationOptions, PaginationResult, SchemaDefinition, SystemFields, TableNamesInDataModel, internalMutationGeneric } from "convex/server";
 import * as convex_values0 from "convex/values";
 import { Infer } from "convex/values";
+import { MiddlewareHandler } from "hono";
 import * as better_auth0 from "better-auth";
 import { BetterAuthOptions, Where, betterAuth } from "better-auth";
 import { GenericCtx } from "@convex-dev/better-auth";
@@ -44,31 +45,31 @@ declare const createClient: <DataModel extends GenericDataModel, Schema$1 extend
 }) => {
   authFunctions: AuthFunctions;
   triggers: Triggers<DataModel, Schema$1> | undefined;
-  adapter: (ctx: GenericCtx<DataModel>, createAuthOptions: (ctx: any) => BetterAuthOptions) => better_auth_adapters0.AdapterFactory;
-  httpAdapter: (ctx: GenericCtx<DataModel>) => better_auth_adapters0.AdapterFactory;
+  adapter: (ctx: GenericCtx<DataModel>, createAuthOptions: (ctx: any) => BetterAuthOptions) => better_auth_adapters1.AdapterFactory;
+  httpAdapter: (ctx: GenericCtx<DataModel>) => better_auth_adapters1.AdapterFactory;
   triggersApi: () => {
-    beforeCreate: convex_server0.RegisteredMutation<"internal", {
+    beforeCreate: convex_server24.RegisteredMutation<"internal", {
       data: any;
       model: string;
     }, Promise<any>>;
-    beforeDelete: convex_server0.RegisteredMutation<"internal", {
+    beforeDelete: convex_server24.RegisteredMutation<"internal", {
       model: string;
       doc: any;
     }, Promise<any>>;
-    beforeUpdate: convex_server0.RegisteredMutation<"internal", {
+    beforeUpdate: convex_server24.RegisteredMutation<"internal", {
       update: any;
       model: string;
       doc: any;
     }, Promise<any>>;
-    onCreate: convex_server0.RegisteredMutation<"internal", {
+    onCreate: convex_server24.RegisteredMutation<"internal", {
       model: string;
       doc: any;
     }, Promise<void>>;
-    onDelete: convex_server0.RegisteredMutation<"internal", {
+    onDelete: convex_server24.RegisteredMutation<"internal", {
       model: string;
       doc: any;
     }, Promise<void>>;
-    onUpdate: convex_server0.RegisteredMutation<"internal", {
+    onUpdate: convex_server24.RegisteredMutation<"internal", {
       model: string;
       newDoc: any;
       oldDoc: any;
@@ -148,7 +149,7 @@ declare const httpAdapter: <DataModel extends GenericDataModel, Schema$1 extends
   authFunctions: AuthFunctions;
   debugLogs?: DBAdapterDebugLogOption;
   triggers?: Triggers<DataModel, Schema$1>;
-}) => better_auth_adapters0.AdapterFactory;
+}) => better_auth_adapters1.AdapterFactory;
 declare const dbAdapter: <DataModel extends GenericDataModel, Schema$1 extends SchemaDefinition<any, any>>(ctx: GenericCtx<DataModel>, createAuthOptions: (ctx: any) => BetterAuthOptions, {
   authFunctions,
   debugLogs,
@@ -159,7 +160,7 @@ declare const dbAdapter: <DataModel extends GenericDataModel, Schema$1 extends S
   schema: Schema$1;
   debugLogs?: DBAdapterDebugLogOption;
   triggers?: Triggers<DataModel, Schema$1>;
-}) => better_auth_adapters0.AdapterFactory;
+}) => better_auth_adapters1.AdapterFactory;
 //#endregion
 //#region src/auth/adapter-utils.d.ts
 declare const adapterWhereValidator: convex_values0.VObject<{
@@ -175,18 +176,18 @@ declare const adapterWhereValidator: convex_values0.VObject<{
 }, "required", "operator" | "value" | "field" | "connector">;
 declare const adapterArgsValidator: convex_values0.VObject<{
   limit?: number | undefined;
-  offset?: number | undefined;
-  select?: string[] | undefined;
-  sortBy?: {
-    field: string;
-    direction: "asc" | "desc";
-  } | undefined;
   where?: {
     operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
     connector?: "AND" | "OR" | undefined;
     value: string | number | boolean | string[] | number[] | null;
     field: string;
   }[] | undefined;
+  select?: string[] | undefined;
+  offset?: number | undefined;
+  sortBy?: {
+    field: string;
+    direction: "asc" | "desc";
+  } | undefined;
   model: string;
 }, {
   limit: convex_values0.VFloat64<number | undefined, "optional">;
@@ -216,7 +217,7 @@ declare const adapterArgsValidator: convex_values0.VObject<{
     operator: convex_values0.VUnion<"eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined, [convex_values0.VLiteral<"lt", "required">, convex_values0.VLiteral<"lte", "required">, convex_values0.VLiteral<"gt", "required">, convex_values0.VLiteral<"gte", "required">, convex_values0.VLiteral<"eq", "required">, convex_values0.VLiteral<"in", "required">, convex_values0.VLiteral<"not_in", "required">, convex_values0.VLiteral<"ne", "required">, convex_values0.VLiteral<"contains", "required">, convex_values0.VLiteral<"starts_with", "required">, convex_values0.VLiteral<"ends_with", "required">], "optional", never>;
     value: convex_values0.VUnion<string | number | boolean | string[] | number[] | null, [convex_values0.VString<string, "required">, convex_values0.VFloat64<number, "required">, convex_values0.VBoolean<boolean, "required">, convex_values0.VArray<string[], convex_values0.VString<string, "required">, "required">, convex_values0.VArray<number[], convex_values0.VFloat64<number, "required">, "required">, convex_values0.VNull<null, "required">], "required", never>;
   }, "required", "operator" | "value" | "field" | "connector">, "optional">;
-}, "required", "limit" | "model" | "offset" | "select" | "sortBy" | "where" | "sortBy.field" | "sortBy.direction">;
+}, "required", "limit" | "where" | "model" | "select" | "offset" | "sortBy" | "sortBy.field" | "sortBy.direction">;
 declare const hasUniqueFields: (betterAuthSchema: BetterAuthDBSchema, model: string, input: Record<string, any>) => boolean;
 declare const checkUniqueFields: <Schema$1 extends SchemaDefinition<any, any>>(ctx: GenericQueryCtx<GenericDataModel>, schema: Schema$1, betterAuthSchema: BetterAuthDBSchema, table: string, input: Record<string, any>, doc?: Record<string, any>) => Promise<void>;
 declare const selectFields: <T extends TableNamesInDataModel<GenericDataModel>, D extends DocumentByName<GenericDataModel, T>>(doc: D | null, select?: string[]) => Promise<D | null>;
@@ -244,7 +245,7 @@ declare const findOneHandler: (ctx: any, args: {
   model: string;
   select?: string[];
   where?: any[];
-}, schema: Schema, betterAuthSchema: any) => Promise<convex_server0.GenericDocument | null>;
+}, schema: Schema, betterAuthSchema: any) => Promise<convex_server24.GenericDocument | null>;
 declare const findManyHandler: (ctx: any, args: {
   model: string;
   paginationOpts: any;
@@ -255,7 +256,7 @@ declare const findManyHandler: (ctx: any, args: {
     field: string;
   };
   where?: any[];
-}, schema: Schema, betterAuthSchema: any) => Promise<convex_server0.PaginationResult<convex_server0.GenericDocument>>;
+}, schema: Schema, betterAuthSchema: any) => Promise<convex_server24.PaginationResult<convex_server24.GenericDocument>>;
 declare const updateOneHandler: (ctx: any, args: {
   input: {
     model: string;
@@ -278,8 +279,8 @@ declare const updateManyHandler: (ctx: any, args: {
   count: number;
   ids: any[];
   isDone: boolean;
-  continueCursor: convex_server0.Cursor;
-  splitCursor?: convex_server0.Cursor | null;
+  continueCursor: convex_server24.Cursor;
+  splitCursor?: convex_server24.Cursor | null;
   pageStatus?: "SplitRecommended" | "SplitRequired" | null;
 }>;
 declare const deleteOneHandler: (ctx: any, args: {
@@ -290,7 +291,7 @@ declare const deleteOneHandler: (ctx: any, args: {
   beforeDeleteHandle?: string;
   skipBeforeHooks?: boolean;
   onDeleteHandle?: string;
-}, schema: Schema, betterAuthSchema: any) => Promise<convex_server0.GenericDocument | undefined>;
+}, schema: Schema, betterAuthSchema: any) => Promise<convex_server24.GenericDocument | undefined>;
 declare const deleteManyHandler: (ctx: any, args: {
   input: {
     model: string;
@@ -304,8 +305,8 @@ declare const deleteManyHandler: (ctx: any, args: {
   count: number;
   ids: any[];
   isDone: boolean;
-  continueCursor: convex_server0.Cursor;
-  splitCursor?: convex_server0.Cursor | null;
+  continueCursor: convex_server24.Cursor;
+  splitCursor?: convex_server24.Cursor | null;
   pageStatus?: "SplitRecommended" | "SplitRequired" | null;
 }>;
 declare const createApi: <Schema$1 extends SchemaDefinition<any, any>>(schema: Schema$1, createAuth: CreateAuth, options?: {
@@ -313,7 +314,7 @@ declare const createApi: <Schema$1 extends SchemaDefinition<any, any>>(schema: S
   /** Skip input validation for smaller generated types. Since these are internal functions, validation is optional. */
   skipValidation?: boolean;
 }) => {
-  create: convex_server0.RegisteredMutation<"internal", {
+  create: convex_server24.RegisteredMutation<"internal", {
     select?: string[] | undefined;
     beforeCreateHandle?: string | undefined;
     onCreateHandle?: string | undefined;
@@ -329,7 +330,7 @@ declare const createApi: <Schema$1 extends SchemaDefinition<any, any>>(schema: S
       model: string;
     };
   }, Promise<any>>;
-  deleteMany: convex_server0.RegisteredMutation<"internal", {
+  deleteMany: convex_server24.RegisteredMutation<"internal", {
     beforeDeleteHandle?: string | undefined;
     onDeleteHandle?: string | undefined;
     paginationOpts: {
@@ -356,11 +357,11 @@ declare const createApi: <Schema$1 extends SchemaDefinition<any, any>>(schema: S
     count: number;
     ids: any[];
     isDone: boolean;
-    continueCursor: convex_server0.Cursor;
-    splitCursor?: convex_server0.Cursor | null;
+    continueCursor: convex_server24.Cursor;
+    splitCursor?: convex_server24.Cursor | null;
     pageStatus?: "SplitRecommended" | "SplitRequired" | null;
   }>>;
-  deleteOne: convex_server0.RegisteredMutation<"internal", {
+  deleteOne: convex_server24.RegisteredMutation<"internal", {
     beforeDeleteHandle?: string | undefined;
     onDeleteHandle?: string | undefined;
     input: {
@@ -375,21 +376,21 @@ declare const createApi: <Schema$1 extends SchemaDefinition<any, any>>(schema: S
       }[] | undefined;
       model: string;
     };
-  }, Promise<convex_server0.GenericDocument | undefined>>;
-  findMany: convex_server0.RegisteredQuery<"internal", {
-    join?: any;
+  }, Promise<convex_server24.GenericDocument | undefined>>;
+  findMany: convex_server24.RegisteredQuery<"internal", {
     limit?: number | undefined;
-    offset?: number | undefined;
-    sortBy?: {
-      field: string;
-      direction: "asc" | "desc";
-    } | undefined;
+    join?: any;
     where?: {
       operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
       connector?: "AND" | "OR" | undefined;
       value: string | number | boolean | string[] | number[] | null;
       field: string;
     }[] | undefined;
+    offset?: number | undefined;
+    sortBy?: {
+      field: string;
+      direction: "asc" | "desc";
+    } | undefined;
     paginationOpts: {
       id?: number;
       endCursor?: string | null;
@@ -399,19 +400,19 @@ declare const createApi: <Schema$1 extends SchemaDefinition<any, any>>(schema: S
       cursor: string | null;
     };
     model: string;
-  }, Promise<convex_server0.PaginationResult<convex_server0.GenericDocument>>>;
-  findOne: convex_server0.RegisteredQuery<"internal", {
+  }, Promise<convex_server24.PaginationResult<convex_server24.GenericDocument>>>;
+  findOne: convex_server24.RegisteredQuery<"internal", {
     join?: any;
-    select?: string[] | undefined;
     where?: {
       operator?: "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "in" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
       connector?: "AND" | "OR" | undefined;
       value: string | number | boolean | string[] | number[] | null;
       field: string;
     }[] | undefined;
+    select?: string[] | undefined;
     model: string;
-  }, Promise<convex_server0.GenericDocument | null>>;
-  updateMany: convex_server0.RegisteredMutation<"internal", {
+  }, Promise<convex_server24.GenericDocument | null>>;
+  updateMany: convex_server24.RegisteredMutation<"internal", {
     beforeUpdateHandle?: string | undefined;
     onUpdateHandle?: string | undefined;
     paginationOpts: {
@@ -444,11 +445,11 @@ declare const createApi: <Schema$1 extends SchemaDefinition<any, any>>(schema: S
     count: number;
     ids: any[];
     isDone: boolean;
-    continueCursor: convex_server0.Cursor;
-    splitCursor?: convex_server0.Cursor | null;
+    continueCursor: convex_server24.Cursor;
+    splitCursor?: convex_server24.Cursor | null;
     pageStatus?: "SplitRecommended" | "SplitRequired" | null;
   }>>;
-  updateOne: convex_server0.RegisteredMutation<"internal", {
+  updateOne: convex_server24.RegisteredMutation<"internal", {
     beforeUpdateHandle?: string | undefined;
     onUpdateHandle?: string | undefined;
     input: {
@@ -470,8 +471,8 @@ declare const createApi: <Schema$1 extends SchemaDefinition<any, any>>(schema: S
       model: string;
     };
   }, Promise<any>>;
-  getLatestJwks: convex_server0.RegisteredAction<"internal", {}, Promise<any>>;
-  rotateKeys: convex_server0.RegisteredAction<"internal", {}, Promise<any>>;
+  getLatestJwks: convex_server24.RegisteredAction<"internal", {}, Promise<any>>;
+  rotateKeys: convex_server24.RegisteredAction<"internal", {}, Promise<any>>;
 };
 //#endregion
 //#region src/auth/helpers.d.ts
@@ -503,14 +504,30 @@ declare const getAuthUserId: <DataModel extends GenericDataModel>(ctx: GenericQu
 declare const getSession: <DataModel extends GenericDataModel>(ctx: GenericQueryCtx<DataModel>, _sessionId?: DocumentByName<DataModel, "session">["_id"]) => Promise<DocumentByName<DataModel, "session"> | null>;
 declare const getHeaders: <DataModel extends GenericDataModel>(ctx: GenericQueryCtx<DataModel>, session?: DocumentByName<DataModel, "session"> | null) => Promise<Headers>;
 //#endregion
-//#region src/auth/registerRoutes.d.ts
-declare const registerRoutes: (http: HttpRouter, createAuth: CreateAuth, opts?: {
-  cors?: {
-    allowedHeaders?: string[];
-    allowedOrigins?: string[];
-    exposedHeaders?: string[];
-  } | boolean;
+//#region src/auth/middleware.d.ts
+interface AuthMiddlewareOptions {
+  /** Base path for auth routes (default: '/api/auth') */
+  basePath?: string;
+  /** Log request/response headers for debugging */
   verbose?: boolean;
-}) => void;
+}
+/**
+ * Create auth middleware that handles auth routes and OpenID well-known redirect.
+ *
+ * @example
+ * ```ts
+ * import { Hono } from 'hono';
+ * import { cors } from 'hono/cors';
+ * import { authMiddleware } from 'better-convex/auth';
+ * import { createHttpRouter } from 'better-convex/server';
+ *
+ * const app = new Hono();
+ * app.use('/api/*', cors({ origin: process.env.SITE_URL, credentials: true }));
+ * app.use(authMiddleware(createAuth));
+ *
+ * export default createHttpRouter(app, appRouter);
+ * ```
+ */
+declare function authMiddleware(createAuth: CreateAuth, opts?: AuthMiddlewareOptions): MiddlewareHandler;
 //#endregion
-export { AuthFunctions, ConvexCleanedWhere, CreateAuth, Triggers, adapterArgsValidator, adapterConfig, adapterWhereValidator, checkUniqueFields, createApi, createClient, createHandler, dbAdapter, deleteManyHandler, deleteOneHandler, findManyHandler, findOneHandler, getAuthUserId, getAuthUserIdentity, getHeaders, getSession, handlePagination, hasUniqueFields, httpAdapter, listOne, paginate, registerRoutes, selectFields, updateManyHandler, updateOneHandler };
+export { AuthFunctions, AuthMiddlewareOptions, ConvexCleanedWhere, CreateAuth, Triggers, adapterArgsValidator, adapterConfig, adapterWhereValidator, authMiddleware, checkUniqueFields, createApi, createClient, createHandler, dbAdapter, deleteManyHandler, deleteOneHandler, findManyHandler, findOneHandler, getAuthUserId, getAuthUserIdentity, getHeaders, getSession, handlePagination, hasUniqueFields, httpAdapter, listOne, paginate, selectFields, updateManyHandler, updateOneHandler };

package/dist/auth/index.js

@@ -1,14 +1,13 @@
 import { isRunMutationCtx } from "@convex-dev/better-auth/utils";
 import { createAdapterFactory } from "better-auth/adapters";
 import { getAuthTables } from "better-auth/db";
-import { createFunctionHandle, httpActionGeneric, internalActionGeneric, internalMutationGeneric, internalQueryGeneric, paginationOptsValidator } from "convex/server";
+import { createFunctionHandle, internalActionGeneric, internalMutationGeneric, internalQueryGeneric, paginationOptsValidator } from "convex/server";
 import { asyncMap } from "convex-helpers";
 import { prop, sortBy, unique } from "remeda";
 import { v } from "convex/values";
 import { partial } from "convex-helpers/validators";
 import { stripIndent } from "common-tags";
 import { mergedStream, stream } from "convex-helpers/server/stream";
-import { corsRouter } from "convex-helpers/server/cors";
 
 //#region src/auth/adapter-utils.ts
 const adapterWhereValidator = v.object({
@@ -958,73 +957,37 @@ const getHeaders = async (ctx, session) => {
 };
 
 //#endregion
-//#region src/auth/registerRoutes.ts
-/** biome-ignore-all lint/suspicious/noConsole: lib */
-const registerRoutes = (http, createAuth, opts = {}) => {
-	const staticAuth = createAuth({});
-	const path = staticAuth.options.basePath ?? "/api/auth";
-	const authRequestHandler = httpActionGeneric(async (ctx, request) => {
-		if (opts?.verbose) {
-			console.log("options.baseURL", staticAuth.options.baseURL);
-			console.log("request headers", request.headers);
+//#region src/auth/middleware.ts
+/**
+* Create auth middleware that handles auth routes and OpenID well-known redirect.
+*
+* @example
+* ```ts
+* import { Hono } from 'hono';
+* import { cors } from 'hono/cors';
+* import { authMiddleware } from 'better-convex/auth';
+* import { createHttpRouter } from 'better-convex/server';
+*
+* const app = new Hono();
+* app.use('/api/*', cors({ origin: process.env.SITE_URL, credentials: true }));
+* app.use(authMiddleware(createAuth));
+*
+* export default createHttpRouter(app, appRouter);
+* ```
+*/
+function authMiddleware(createAuth, opts = {}) {
+	const basePath = opts.basePath ?? "/api/auth";
+	return async (c, next) => {
+		if (c.req.path === "/.well-known/openid-configuration") return c.redirect(`${process.env.CONVEX_SITE_URL}${basePath}/convex/.well-known/openid-configuration`);
+		if (c.req.path.startsWith(basePath)) {
+			if (opts.verbose) console.log("request headers", c.req.raw.headers);
+			const response = await createAuth(c.env).handler(c.req.raw);
+			if (opts.verbose) console.log("response headers", response.headers);
+			return response;
 		}
-		const response = await createAuth(ctx).handler(request);
-		if (opts?.verbose) console.log("response headers", response.headers);
-		return response;
-	});
-	if (!http.lookup("/.well-known/openid-configuration", "GET")) http.route({
-		handler: httpActionGeneric(async () => {
-			const url = `${process.env.CONVEX_SITE_URL}${path}/convex/.well-known/openid-configuration`;
-			return Response.redirect(url);
-		}),
-		method: "GET",
-		path: "/.well-known/openid-configuration"
-	});
-	if (!opts.cors) {
-		http.route({
-			handler: authRequestHandler,
-			method: "GET",
-			pathPrefix: `${path}/`
-		});
-		http.route({
-			handler: authRequestHandler,
-			method: "POST",
-			pathPrefix: `${path}/`
-		});
-		return;
-	}
-	const corsOpts = typeof opts.cors === "boolean" ? {
-		allowedHeaders: [],
-		allowedOrigins: [],
-		exposedHeaders: []
-	} : opts.cors;
-	let trustedOriginsOption;
-	const cors = corsRouter(http, {
-		allowCredentials: true,
-		allowedHeaders: [
-			"Content-Type",
-			"Better-Auth-Cookie",
-			"Authorization"
-		].concat(corsOpts.allowedHeaders ?? []),
-		debug: opts?.verbose,
-		enforceAllowOrigins: false,
-		exposedHeaders: ["Set-Better-Auth-Cookie"].concat(corsOpts.exposedHeaders ?? []),
-		allowedOrigins: async (request) => {
-			trustedOriginsOption = trustedOriginsOption ?? (await staticAuth.$context).options.trustedOrigins ?? [];
-			return (Array.isArray(trustedOriginsOption) ? trustedOriginsOption : await trustedOriginsOption?.(request) ?? []).map((origin) => origin.endsWith("*") && origin.length > 1 ? origin.slice(0, -1) : origin).concat(corsOpts.allowedOrigins ?? []);
-		}
-	});
-	cors.route({
-		handler: authRequestHandler,
-		method: "GET",
-		pathPrefix: `${path}/`
-	});
-	cors.route({
-		handler: authRequestHandler,
-		method: "POST",
-		pathPrefix: `${path}/`
-	});
-};
+		return next();
+	};
+}
 
 //#endregion
-export { adapterArgsValidator, adapterConfig, adapterWhereValidator, checkUniqueFields, createApi, createClient, createHandler, dbAdapter, deleteManyHandler, deleteOneHandler, findManyHandler, findOneHandler, getAuthUserId, getAuthUserIdentity, getHeaders, getSession, handlePagination, hasUniqueFields, httpAdapter, listOne, paginate, registerRoutes, selectFields, updateManyHandler, updateOneHandler };
+export { adapterArgsValidator, adapterConfig, adapterWhereValidator, authMiddleware, checkUniqueFields, createApi, createClient, createHandler, dbAdapter, deleteManyHandler, deleteOneHandler, findManyHandler, findOneHandler, getAuthUserId, getAuthUserIdentity, getHeaders, getSession, handlePagination, hasUniqueFields, httpAdapter, listOne, paginate, selectFields, updateManyHandler, updateOneHandler };

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

@@ -1,4 +1,4 @@
-import "../http-types-BwEQgYV1.js";
+import "../http-types-CZo9Xx5R.js";
 import { CallerMeta, ConvexContext, LazyCaller } from "../server/index.js";
 import { GetTokenOptions } from "@convex-dev/better-auth/utils";
 

package/dist/cli.cjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const require_codegen = require('./codegen-Cca0gj6d.cjs');
+const require_codegen = require('./codegen-CdL9lB4u.cjs');
 let node_module = require("node:module");
 let node_path = require("node:path");
 node_path = require_codegen.__toESM(node_path);

package/dist/{codegen-Cca0gj6d.cjs → codegen-CdL9lB4u.cjs}

@@ -55,11 +55,15 @@ function isCRPCHttpRouter(value) {
 async function parseModuleRuntime(filePath, jiti$1) {
 	const result = {};
 	const httpRoutes = {};
+	const isHttp = filePath.endsWith("http.ts");
 	const module$1 = await jiti$1.import(filePath);
-	if (!module$1 || typeof module$1 !== "object") return {
-		meta: null,
-		httpRoutes: {}
-	};
+	if (!module$1 || typeof module$1 !== "object") {
+		if (isHttp) console.error("  http.ts: module is empty or not an object");
+		return {
+			meta: null,
+			httpRoutes: {}
+		};
+	}
 	for (const [name, value] of Object.entries(module$1)) {
 		if (name.startsWith("_")) continue;
 		const meta = value?._crpcMeta;
@@ -117,9 +121,10 @@ async function generateMeta(outputDir, options) {
 				totalFunctions += fnCount;
 				if (debug) console.info(`  ✓ ${moduleName}: ${fnCount} functions`);
 			}
+			if (Object.keys(httpRoutes).length > 0 && debug) console.info(`  ✓ ${moduleName}: ${Object.keys(httpRoutes).length} HTTP routes`);
 			Object.assign(allHttpRoutes, httpRoutes);
 		} catch (error) {
-			if (debug) console.error(`  ⚠ Failed to parse ${file}:`, error);
+			if (debug || file === "http.ts") console.error(`  ⚠ Failed to parse ${file}:`, error);
 		}
 	}
 	const metaEntries = Object.entries(meta).map(([module$1, fns]) => {

package/dist/crpc/index.d.ts

@@ -1,5 +1,5 @@
-import { _ as HttpRouterRecord, a as HttpErrorCode, c as HttpRouteMap, d as isHttpClientError, h as CRPCHttpRouter, i as HttpClientOptions, l as InferHttpInput, n as HttpClientError, o as HttpProcedureCall, r as HttpClientFromRouter, s as HttpRouteInfo, t as HttpClient, u as InferHttpOutput } from "../http-types-BwEQgYV1.js";
-import { C as PaginatedFnMeta, S as Meta, _ as ExtractPaginatedItem, a as ConvexInfiniteQueryMeta, b as InfiniteQueryInput, c as ConvexMutationKey, d as ConvexQueryMeta, f as ConvexQueryOptions, g as DecorateQuery, h as DecorateMutation, i as ConvexActionOptions, l as ConvexQueryHookOptions, m as DecorateInfiniteQuery, n as CRPCClient, o as ConvexInfiniteQueryOptions, p as DecorateAction, r as ConvexActionKey, s as ConvexInfiniteQueryOptionsWithRef, t as AuthType, u as ConvexQueryKey, v as FUNC_REF_SYMBOL, w as PaginationOpts, x as InfiniteQueryOptsParam, y as FnMeta } from "../types-DLVNrXKq.js";
+import { a as HttpProcedureCall, c as InferHttpInput, i as HttpErrorCode, l as InferHttpOutput, n as HttpClientError, o as HttpRouteInfo, r as HttpClientFromRouter, s as HttpRouteMap, t as HttpClient, u as isHttpClientError } from "../http-types-CZo9Xx5R.js";
+import { C as PaginatedFnMeta, S as Meta, _ as ExtractPaginatedItem, a as ConvexInfiniteQueryMeta, b as InfiniteQueryInput, c as ConvexMutationKey, d as ConvexQueryMeta, f as ConvexQueryOptions, g as DecorateQuery, h as DecorateMutation, i as ConvexActionOptions, l as ConvexQueryHookOptions, m as DecorateInfiniteQuery, n as CRPCClient, o as ConvexInfiniteQueryOptions, p as DecorateAction, r as ConvexActionKey, s as ConvexInfiniteQueryOptionsWithRef, t as AuthType, u as ConvexQueryKey, v as FUNC_REF_SYMBOL, w as PaginationOpts, x as InfiniteQueryOptsParam, y as FnMeta } from "../types-U9pc_wi1.js";
 import { FunctionArgs, FunctionReference } from "convex/server";
 
 //#region src/crpc/error.d.ts
@@ -28,44 +28,6 @@ declare const isCRPCErrorCode: (error: unknown, code: ClientErrorCode) => error
 /** Default unauthorized detection - checks UNAUTHORIZED code */
 declare const defaultIsUnauthorized: (error: unknown) => boolean;
 //#endregion
-//#region src/crpc/http-client.d.ts
-
-/**
- * Create a typed HTTP client for cRPC HTTP routers
- *
- * Supports nested router access like tRPC:
- * - `http.todos.get({ id })` for nested routers
- * - `http.health()` for flat procedures
- *
- * For React apps, prefer using `createCRPCContext` with HTTP options
- * which provides TanStack Query integration (queryOptions, mutationOptions).
- *
- * @example
- * ```ts
- * import { createHttpClient } from 'better-convex/crpc';
- * import { meta } from '../convex/shared/meta';
- * import type { AppRouter } from '../convex/functions/http';
- *
- * const http = createHttpClient<AppRouter>({
- *   convexSiteUrl: process.env.NEXT_PUBLIC_CONVEX_SITE_URL!,
- *   routes: meta._http!, // HTTP routes are in meta._http
- * });
- *
- * // Nested access
- * const todo = await http.todos.get({ id: 'abc123' });
- *
- * // Flat access
- * const health = await http.health();
- * ```
- */
-declare function createHttpClient<TRouter extends CRPCHttpRouter<any>, TRoutes extends HttpRouteMap = HttpRouteMap>(opts: HttpClientOptions<TRoutes>): HttpClientFromRouter<TRouter>;
-/**
- * Create a typed HTTP client for flat HTTP router record
- *
- * @deprecated Prefer passing a CRPCHttpRouter type for nested access
- */
-declare function createHttpClient<TRouter extends HttpRouterRecord, TRoutes extends HttpRouteMap = HttpRouteMap>(opts: HttpClientOptions<TRoutes>): HttpClient<TRouter>;
-//#endregion
 //#region src/crpc/query-options.d.ts
 /**
  * Query options factory for Convex query function subscriptions.
@@ -106,4 +68,4 @@ declare function convexAction<T extends FunctionReference<'action'>>(funcRef: T,
  */
 declare function convexInfiniteQueryOptions<T extends FunctionReference<'query'>>(funcRef: T, args: Record<string, unknown> | 'skip', opts?: InfiniteQueryOptsParam<T>, meta?: Meta): ConvexInfiniteQueryOptions<T>;
 //#endregion
-export { AuthType, CRPCClient, CRPCClientError, ConvexActionKey, ConvexActionOptions, ConvexInfiniteQueryMeta, ConvexInfiniteQueryOptions, ConvexInfiniteQueryOptionsWithRef, ConvexMutationKey, ConvexQueryHookOptions, ConvexQueryKey, ConvexQueryMeta, ConvexQueryOptions, DecorateAction, DecorateInfiniteQuery, DecorateMutation, DecorateQuery, ExtractPaginatedItem, FUNC_REF_SYMBOL, FnMeta, HttpClient, HttpClientError, HttpClientFromRouter, HttpClientOptions, HttpErrorCode, HttpProcedureCall, HttpRouteInfo, HttpRouteMap, InferHttpInput, InferHttpOutput, InfiniteQueryInput, InfiniteQueryOptsParam, Meta, PaginatedFnMeta, PaginationOpts, convexAction, convexInfiniteQueryOptions, convexQuery, createHttpClient, defaultIsUnauthorized, isCRPCClientError, isCRPCErrorCode, isHttpClientError };
+export { AuthType, CRPCClient, CRPCClientError, ConvexActionKey, ConvexActionOptions, ConvexInfiniteQueryMeta, ConvexInfiniteQueryOptions, ConvexInfiniteQueryOptionsWithRef, ConvexMutationKey, ConvexQueryHookOptions, ConvexQueryKey, ConvexQueryMeta, ConvexQueryOptions, DecorateAction, DecorateInfiniteQuery, DecorateMutation, DecorateQuery, ExtractPaginatedItem, FUNC_REF_SYMBOL, FnMeta, HttpClient, HttpClientError, HttpClientFromRouter, HttpErrorCode, HttpProcedureCall, HttpRouteInfo, HttpRouteMap, InferHttpInput, InferHttpOutput, InfiniteQueryInput, InfiniteQueryOptsParam, Meta, PaginatedFnMeta, PaginationOpts, convexAction, convexInfiniteQueryOptions, convexQuery, defaultIsUnauthorized, isCRPCClientError, isCRPCErrorCode, isHttpClientError };

package/dist/crpc/index.js

@@ -18,112 +18,10 @@ var HttpClientError = class extends Error {
 /** Type guard for HttpClientError */
 const isHttpClientError = (error) => error instanceof HttpClientError;
 
-//#endregion
-//#region src/crpc/http-client.ts
-/**
-* Extract path parameter names from a route path
-* e.g., '/users/:id/posts/:postId' -> ['id', 'postId']
-*/
-function extractPathParamNames(path) {
-	const matches = path.match(/:([a-zA-Z_][a-zA-Z0-9_]*)/g);
-	return matches ? matches.map((m) => m.slice(1)) : [];
-}
-/**
-* Execute an HTTP request to a cRPC endpoint
-*/
-async function executeHttpRequest(opts) {
-	const { method, path } = opts.route;
-	const input = opts.input;
-	const pathParamNames = extractPathParamNames(path);
-	let url = opts.convexSiteUrl + path.replace(/:(\w+)/g, (_, key) => {
-		const value = input?.[key];
-		return value !== null && value !== void 0 ? encodeURIComponent(String(value)) : "";
-	});
-	const headers = typeof opts.headers === "function" ? await opts.headers() : opts.headers;
-	let body;
-	if (method === "GET") {
-		const queryInput = input ? Object.fromEntries(Object.entries(input).filter(([k]) => !pathParamNames.includes(k))) : {};
-		if (Object.keys(queryInput).length > 0) {
-			const params = new URLSearchParams();
-			for (const [key, value] of Object.entries(queryInput)) if (value !== void 0 && value !== null) params.append(key, String(value));
-			const queryString = params.toString();
-			if (queryString) url += `?${queryString}`;
-		}
-	} else {
-		const bodyInput = input ? Object.fromEntries(Object.entries(input).filter(([k]) => !pathParamNames.includes(k))) : {};
-		if (Object.keys(bodyInput).length > 0) body = JSON.stringify(bodyInput);
-	}
-	const response = await (opts.fetch ?? globalThis.fetch)(url, {
-		method,
-		headers: {
-			"Content-Type": "application/json",
-			...headers
-		},
-		body
-	});
-	if (!response.ok) {
-		const errorData = await response.json().catch(() => ({ error: {
-			code: "UNKNOWN",
-			message: response.statusText
-		} }));
-		const errorCode = errorData?.error?.code || "UNKNOWN";
-		const errorMessage = errorData?.error?.message || response.statusText;
-		throw new HttpClientError({
-			code: errorCode,
-			status: response.status,
-			procedureName: opts.procedureName,
-			message: errorMessage
-		});
-	}
-	if (response.headers.get("content-length") === "0" || response.status === 204) return;
-	return response.json();
-}
-/**
-* Create a recursive proxy for nested route access
-* Tracks path segments and executes request when function is called
-*/
-function createRecursiveProxy(opts, path = []) {
-	return new Proxy(() => {}, {
-		get(_, key) {
-			return createRecursiveProxy(opts, [...path, key]);
-		},
-		apply(_, __, args) {
-			const procedureName = path.join(".");
-			const route = opts.routes[procedureName];
-			if (!route) throw new Error(`Unknown HTTP procedure: ${procedureName}`);
-			return (async () => {
-				try {
-					return await executeHttpRequest({
-						convexSiteUrl: opts.convexSiteUrl,
-						route,
-						procedureName,
-						input: args[0],
-						headers: opts.headers,
-						fetch: opts.fetch
-					});
-				} catch (error) {
-					if (opts.onError && error instanceof HttpClientError) opts.onError(error);
-					throw error;
-				}
-			})();
-		}
-	});
-}
-function createHttpClient(opts) {
-	const { convexSiteUrl, routes, headers, fetch: customFetch, onError } = opts;
-	return createRecursiveProxy({
-		convexSiteUrl,
-		routes,
-		headers,
-		fetch: customFetch,
-		onError
-	});
-}
-
 //#endregion
 //#region src/crpc/types.ts
 /** Symbol key for attaching FunctionReference to options (non-serializable) */
 const FUNC_REF_SYMBOL = Symbol.for("convex.funcRef");
 
 //#endregion
-export { CRPCClientError, FUNC_REF_SYMBOL, HttpClientError, convexAction, convexInfiniteQueryOptions, convexQuery, createHttpClient, defaultIsUnauthorized, isCRPCClientError, isCRPCErrorCode, isHttpClientError };
+export { CRPCClientError, FUNC_REF_SYMBOL, HttpClientError, convexAction, convexInfiniteQueryOptions, convexQuery, defaultIsUnauthorized, isCRPCClientError, isCRPCErrorCode, isHttpClientError };