better-convex 0.9.1 → 0.10.0

package/dist/aggregate/index.d.ts

@@ -1,4 +1,7 @@
-import { Dt as ConvexCustomBuilderInitial, _t as ConvexNumberBuilderInitial, bt as ConvexIdBuilderInitial, qn as ConvexTextBuilderInitial, rn as ConvexTableWithColumns } from "../where-clause-compiler-UavDdMUX.js";
+import "../validators-BcQFm1oY.js";
+import { Jn as ConvexTextBuilderInitial, Ot as ConvexCustomBuilderInitial, in as ConvexTableWithColumns, vt as ConvexNumberBuilderInitial, xt as ConvexIdBuilderInitial } from "../where-clause-compiler-DjFwXrQn.js";
+import "../query-context-ji7By8u0.js";
+import "../orm/index.js";
 import * as convex_values0 from "convex/values";
 import { GenericId, Infer, Value } from "convex/values";
 import { DocumentByName, GenericDataModel, GenericDatabaseReader, GenericDatabaseWriter, TableNamesInDataModel } from "convex/server";

package/dist/auth/index.d.ts

@@ -1,6 +1,7 @@
+import "../validators-BcQFm1oY.js";
 import { a as QueryCtxWithPreferredOrmQueryTable, n as LookupByIdResultByCtx, t as DocByCtx } from "../query-context-ji7By8u0.js";
 import { t as GetAuth } from "../types-CM67ko7K.js";
-import { A as GenericCtx } from "../procedure-caller-DYjpq7rG.js";
+import { A as GenericCtx } from "../procedure-caller-kZJx_hmP.js";
 import "../http-types-BK7FuIcR.js";
 import "../server/index.js";
 import * as convex_values0 from "convex/values";
@@ -196,8 +197,8 @@ declare const adapterArgsValidator: convex_values0.VObject<{
   select?: string[] | undefined;
   offset?: number | undefined;
   sortBy?: {
-    direction: "asc" | "desc";
     field: string;
+    direction: "asc" | "desc";
   } | undefined;
   where?: {
     connector?: "AND" | "OR" | undefined;
@@ -212,12 +213,12 @@ declare const adapterArgsValidator: convex_values0.VObject<{
   offset: convex_values0.VFloat64<number | undefined, "optional">;
   select: convex_values0.VArray<string[] | undefined, convex_values0.VString<string, "required">, "optional">;
   sortBy: convex_values0.VObject<{
-    direction: "asc" | "desc";
     field: string;
+    direction: "asc" | "desc";
   } | undefined, {
     direction: convex_values0.VUnion<"asc" | "desc", [convex_values0.VLiteral<"asc", "required">, convex_values0.VLiteral<"desc", "required">], "required", never>;
     field: convex_values0.VString<string, "required">;
-  }, "optional", "direction" | "field">;
+  }, "optional", "field" | "direction">;
   where: convex_values0.VArray<{
     connector?: "AND" | "OR" | undefined;
     operator?: "in" | "lt" | "lte" | "gt" | "gte" | "eq" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
@@ -234,7 +235,7 @@ declare const adapterArgsValidator: convex_values0.VObject<{
     operator: convex_values0.VUnion<"in" | "lt" | "lte" | "gt" | "gte" | "eq" | "not_in" | "ne" | "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", "value" | "connector" | "field" | "operator">, "optional">;
-}, "required", "limit" | "model" | "select" | "offset" | "sortBy" | "where" | "sortBy.direction" | "sortBy.field">;
+}, "required", "limit" | "model" | "select" | "offset" | "sortBy" | "where" | "sortBy.field" | "sortBy.direction">;
 declare const hasUniqueFields: (betterAuthSchema: BetterAuthDBSchema, model: string, input: Record<string, any>) => boolean;
 declare const checkUniqueFields: <Schema extends SchemaDefinition<any, any>>(ctx: GenericQueryCtx<GenericDataModel>, schema: Schema, 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>;
@@ -406,8 +407,8 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>, DataModel e
     join?: any;
     offset?: number | undefined;
     sortBy?: {
-      direction: "asc" | "desc";
       field: string;
+      direction: "asc" | "desc";
     } | undefined;
     where?: {
       connector?: "AND" | "OR" | undefined;
@@ -436,6 +437,8 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>, DataModel e
     }[] | undefined;
     model: string;
   }, Promise<convex_server0.GenericDocument | null>>;
+  getLatestJwks: convex_server0.RegisteredAction<"internal", {}, Promise<unknown>>;
+  rotateKeys: convex_server0.RegisteredAction<"internal", {}, Promise<unknown>>;
   updateMany: convex_server0.RegisteredMutation<"internal", {
     input: {
       where?: {
@@ -491,8 +494,6 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>, DataModel e
       model: string;
     };
   }, Promise<any>>;
-  getLatestJwks: convex_server0.RegisteredAction<"internal", {}, Promise<unknown>>;
-  rotateKeys: convex_server0.RegisteredAction<"internal", {}, Promise<unknown>>;
 };
 //#endregion
 //#region ../../node_modules/kysely/dist/esm/operation-node/operation-node.d.ts
@@ -19202,8 +19203,8 @@ declare const createAuthRuntime: <DataModel extends GenericDataModel, Schema ext
     join?: any;
     offset?: number | undefined;
     sortBy?: {
-      direction: "asc" | "desc";
       field: string;
+      direction: "asc" | "desc";
     } | undefined;
     where?: {
       connector?: "AND" | "OR" | undefined;
@@ -19232,6 +19233,8 @@ declare const createAuthRuntime: <DataModel extends GenericDataModel, Schema ext
     }[] | undefined;
     model: string;
   }, Promise<convex_server0.GenericDocument | null>>;
+  getLatestJwks: convex_server0.RegisteredAction<"internal", {}, Promise<unknown>>;
+  rotateKeys: convex_server0.RegisteredAction<"internal", {}, Promise<unknown>>;
   updateMany: convex_server0.RegisteredMutation<"internal", {
     input: {
       where?: {
@@ -19287,8 +19290,6 @@ declare const createAuthRuntime: <DataModel extends GenericDataModel, Schema ext
       model: string;
     };
   }, Promise<any>>;
-  getLatestJwks: convex_server0.RegisteredAction<"internal", {}, Promise<unknown>>;
-  rotateKeys: convex_server0.RegisteredAction<"internal", {}, Promise<unknown>>;
   authEnabled: true;
   authClient: {
     authFunctions: AuthFunctions;

package/dist/auth/index.js

@@ -315,7 +315,7 @@ const resolveOrmTable = (ctx, schema, betterAuthSchema, model) => {
 	const tableName = resolveSchemaTableName(schema, betterAuthSchema, model);
 	if (!tableName) return;
 	const table = schema.tables[tableName];
-	if (!table || !table._id) return;
+	if (!table?._id) return;
 	return {
 		table,
 		tableName
@@ -409,10 +409,19 @@ const serializeDatesForConvex = (value) => {
 	return serialized ?? value;
 };
 const toConvexSafe = (value) => serializeDatesForConvex(value);
+const withAuthTimestamps = (data) => {
+	if (data.createdAt !== void 0) return data;
+	const now = Date.now();
+	return {
+		...data,
+		createdAt: now,
+		...data.updatedAt === void 0 ? { updatedAt: now } : {}
+	};
+};
 const createHandler = async (ctx, args, schema, betterAuthSchema) => {
 	const triggerCtx = args.triggerCtx ?? ctx;
 	const tableTriggers = args.tableTriggers;
-	const data = serializeDatesForConvex(await applyBeforeHook(args.input.model, "create", args.input.data, tableTriggers?.create?.before, triggerCtx));
+	const data = serializeDatesForConvex(withAuthTimestamps(await applyBeforeHook(args.input.model, "create", args.input.data, tableTriggers?.create?.before, triggerCtx)));
 	await checkUniqueFields(ctx, schema, betterAuthSchema, args.input.model, data);
 	const ormTable = resolveOrmTable(ctx, schema, betterAuthSchema, args.input.model);
 	const doc = ormTable ? await ormInsert(ctx, ormTable.table, data) : await (async () => {
@@ -639,6 +648,7 @@ const createApi = (schema, getAuth, options) => {
 		}),
 		findMany: internalQueryGeneric({
 			args: {
+				join: v.optional(v.any()),
 				limit: v.optional(v.number()),
 				model: modelValidator,
 				offset: v.optional(v.number()),
@@ -647,20 +657,31 @@ const createApi = (schema, getAuth, options) => {
 					direction: v.union(v.literal("asc"), v.literal("desc")),
 					field: v.string()
 				})),
-				where: v.optional(v.array(adapterWhereValidator)),
-				join: v.optional(v.any())
+				where: v.optional(v.array(adapterWhereValidator))
 			},
 			handler: async (ctx, args) => findManyHandler(ctx, args, schema, getBetterAuthSchema())
 		}),
 		findOne: internalQueryGeneric({
 			args: {
+				join: v.optional(v.any()),
 				model: modelValidator,
 				select: v.optional(v.array(v.string())),
-				where: v.optional(v.array(adapterWhereValidator)),
-				join: v.optional(v.any())
+				where: v.optional(v.array(adapterWhereValidator))
 			},
 			handler: async (ctx, args) => findOneHandler(ctx, args, schema, getBetterAuthSchema())
 		}),
+		getLatestJwks: internalActionGeneric({
+			args: {},
+			handler: async (ctx) => {
+				return getAuth(ctx).api.getLatestJwks();
+			}
+		}),
+		rotateKeys: internalActionGeneric({
+			args: {},
+			handler: async (ctx) => {
+				return getAuth(ctx).api.rotateKeys();
+			}
+		}),
 		updateMany: mutationBuilder({
 			args: {
 				input: updateInput,
@@ -686,18 +707,6 @@ const createApi = (schema, getAuth, options) => {
 					triggerCtx
 				}, schema, getBetterAuthSchema());
 			}
-		}),
-		getLatestJwks: internalActionGeneric({
-			args: {},
-			handler: async (ctx) => {
-				return getAuth(ctx).api.getLatestJwks();
-			}
-		}),
-		rotateKeys: internalActionGeneric({
-			args: {},
-			handler: async (ctx) => {
-				return getAuth(ctx).api.rotateKeys();
-			}
 		})
 	};
 };

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

@@ -1,4 +1,5 @@
-import { B as ConvexContext, H as LazyCaller } from "../../procedure-caller-DYjpq7rG.js";
+import "../../validators-BcQFm1oY.js";
+import { B as ConvexContext, H as LazyCaller } from "../../procedure-caller-kZJx_hmP.js";
 import "../../http-types-BK7FuIcR.js";
 import "../../server/index.js";
 import { GetTokenOptions } from "@convex-dev/better-auth/utils";
@@ -12,7 +13,8 @@ type AuthOptions = {
 };
 type ConvexBetterAuthOptions<TApi> = Omit<GetTokenOptions, 'jwtCache'> & {
   api: TApi;
-  convexSiteUrl: string; /** Auth options. JWT caching is enabled by default (set `auth.jwtCache: false` to disable). */
+  convexSiteUrl: string;
+  convexUrl?: string; /** Auth options. JWT caching is enabled by default (set `auth.jwtCache: false` to disable). */
   auth?: AuthOptions;
 };
 /**
@@ -38,10 +40,10 @@ type ConvexBetterAuthOptions<TApi> = Omit<GetTokenOptions, 'jwtCache'> & {
  * ```
  */
 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>>;
-  createCaller: (ctxFn: () => Promise<ConvexContext<TApi>>) => LazyCaller<TApi>;
   handler: {
     GET: (request: Request) => Promise<Response>;
     POST: (request: Request) => Promise<Response>;

package/dist/auth/nextjs/index.js

@@ -1,5 +1,5 @@
 import { n as defaultIsUnauthorized } from "../../error-CAGGSN5H.js";
-import { t as createCallerFactory } from "../../caller-factory-CCsm4Dut.js";
+import { t as createCallerFactory } from "../../caller-factory-C1uAqm5w.js";
 import { getToken } from "@convex-dev/better-auth/utils";
 
 //#region src/auth-nextjs/index.ts
@@ -50,7 +50,6 @@ function convexBetterAuth(opts) {
 	const jwtCacheEnabled = auth.jwtCache !== false;
 	const { createContext, createCaller } = createCallerFactory({
 		api: opts.api,
-		convexSiteUrl: opts.convexSiteUrl,
 		auth: jwtCacheEnabled ? {
 			getToken: (siteUrl, headers, getTokenOpts) => {
 				const mutableHeaders = new Headers(headers);
@@ -66,11 +65,13 @@ function convexBetterAuth(opts) {
 				});
 			},
 			isUnauthorized: auth.isUnauthorized ?? defaultIsUnauthorized
-		} : void 0
+		} : void 0,
+		convexSiteUrl: opts.convexSiteUrl,
+		convexUrl: opts.convexUrl
 	});
 	return {
-		createContext,
 		createCaller,
+		createContext,
 		handler: nextJsHandler(opts.convexSiteUrl)
 	};
 }

package/dist/{caller-factory-CCsm4Dut.js → caller-factory-C1uAqm5w.js}

@@ -116,12 +116,20 @@ function createLazyCaller(api, createContext) {
 * Framework-agnostic caller factory.
 * getToken is passed as a parameter - decoupled from @convex-dev/better-auth.
 */
-const getArgsAndOptions = (args, token) => [args[0], { token }];
+const CONVEX_SITE_URL_RE = /\.convex\.site(?=\/|$)/;
+const getArgsAndOptions = (args, token, url) => [args[0], {
+	token,
+	url
+}];
 const parseConvexSiteUrl = (url) => {
 	if (!url) throw new Error("CONVEX_SITE_URL is not set. This must be set in the environment.");
 	if (url.endsWith(".convex.cloud")) throw new Error(`CONVEX_SITE_URL should end in .convex.site, not .convex.cloud. Currently set to ${url}.`);
 	return url;
 };
+const getConvexUrl = (siteUrl, convexUrl) => {
+	if (convexUrl) return convexUrl;
+	return siteUrl.replace(CONVEX_SITE_URL_RE, ".convex.cloud");
+};
 /**
 * Framework-agnostic caller factory.
 *
@@ -137,6 +145,7 @@ const parseConvexSiteUrl = (url) => {
 const noAuthGetToken = () => Promise.resolve({ token: void 0 });
 function createCallerFactory(opts) {
 	const siteUrl = parseConvexSiteUrl(opts.convexSiteUrl);
+	const convexUrl = getConvexUrl(siteUrl, opts.convexUrl);
 	const getToken = opts.auth?.getToken ?? noAuthGetToken;
 	const isUnauthorized = opts.auth?.isUnauthorized;
 	const crpcMeta = buildMetaIndex(opts.api);
@@ -166,40 +175,40 @@ function createCallerFactory(opts) {
 		const fetchAuthQuery = async (query, args, callerOpts) => {
 			if (callerOpts?.skipUnauth && !tokenResult.token) return null;
 			return callWithTokenAndRetry((token) => {
-				const argsAndOptions = getArgsAndOptions([args], token);
+				const argsAndOptions = getArgsAndOptions([args], token, convexUrl);
 				return fetchQuery(query, argsAndOptions[0], argsAndOptions[1]);
 			}, tokenResult, reqOpts.headers);
 		};
 		const fetchAuthMutation = async (mutation, args, callerOpts) => {
 			if (callerOpts?.skipUnauth && !tokenResult.token) return null;
 			return callWithTokenAndRetry((token) => {
-				const argsAndOptions = getArgsAndOptions([args], token);
+				const argsAndOptions = getArgsAndOptions([args], token, convexUrl);
 				return fetchMutation(mutation, argsAndOptions[0], argsAndOptions[1]);
 			}, tokenResult, reqOpts.headers);
 		};
 		const fetchAuthAction = async (action, args, callerOpts) => {
 			if (callerOpts?.skipUnauth && !tokenResult.token) return null;
 			return callWithTokenAndRetry((token) => {
-				const argsAndOptions = getArgsAndOptions([args], token);
+				const argsAndOptions = getArgsAndOptions([args], token, convexUrl);
 				return fetchAction(action, argsAndOptions[0], argsAndOptions[1]);
 			}, tokenResult, reqOpts.headers);
 		};
 		return {
-			token: tokenResult.token,
-			isAuthenticated: !!tokenResult.token,
 			caller: createServerCaller(opts.api, {
-				fetchQuery: fetchAuthQuery,
-				fetchMutation: fetchAuthMutation,
 				fetchAction: fetchAuthAction,
+				fetchMutation: fetchAuthMutation,
+				fetchQuery: fetchAuthQuery,
 				meta: crpcMeta,
 				transformer: opts.transformer
-			})
+			}),
+			isAuthenticated: !!tokenResult.token,
+			token: tokenResult.token
 		};
 	};
 	const createCaller = (ctxFn) => createLazyCaller(opts.api, ctxFn);
 	return {
-		createContext,
-		createCaller
+		createCaller,
+		createContext
 	};
 }
 

package/dist/crpc/index.d.ts

@@ -1,7 +1,36 @@
 import { $ as identityTransformer, G as DataTransformerOptions, H as CombinedDataTransformer, J as dateWireCodec, K as WireCodec, Q as getTransformer, U as DATE_CODEC_TAG, W as DataTransformer, X as defaultCRPCTransformer, Y as decodeWire, Z as encodeWire, a as HttpProcedureCall, c as InferHttpInput, i as HttpErrorCode, l as InferHttpOutput, n as HttpClientError, o as HttpRouteInfo, q as createTaggedTransformer, r as HttpClientFromRouter, s as HttpRouteMap, t as HttpClient, u as isHttpClientError } from "../http-types-BK7FuIcR.js";
-import { C as PaginatedFnMeta, D as VanillaMutation, E as VanillaCRPCClient, O as VanillaQuery, S as Meta, T as VanillaAction, _ 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-f53SgpBL.js";
+import { A as HttpInputArgs, C as ReservedMutationOptions, D as VanillaMutation, E as VanillaAction, F as replaceUrlParam, M as RESERVED_KEYS, N as buildSearchParams, O as HttpClientOptions, P as executeHttpRequest, S as ReservedInfiniteQueryOptions, T as StaticQueryOptsParam, _ as IsPaginated, a as BaseInfiniteQueryOptsParam, b as PaginatedFnMeta, c as ConvexMutationKey, d as ConvexQueryMeta, f as EmptyObject, g as InfiniteQueryInput, h as FnMeta, i as BaseConvexQueryOptions, j as HttpProxyBaseOptions, k as HttpFormValue, l as ConvexQueryHookOptions, m as FUNC_REF_SYMBOL, n as BaseConvexActionOptions, o as ConvexActionKey, p as ExtractPaginatedItem, r as BaseConvexInfiniteQueryOptions, s as ConvexInfiniteQueryMeta, t as AuthType, u as ConvexQueryKey, v as Meta, w as ReservedQueryOptions, x as PaginationOpts, y as MutationVariables } from "../types-7bF_8IjP.js";
 import { FunctionArgs, FunctionReference } from "convex/server";
 
+//#region src/crpc/auth-error.d.ts
+/**
+ * Auth Mutation Error
+ *
+ * Framework-agnostic error class for Better Auth mutations.
+ */
+/**
+ * Error thrown when a Better Auth mutation fails.
+ * Contains the original error details from Better Auth.
+ */
+declare class AuthMutationError extends Error {
+  /** Error code from Better Auth (e.g., 'INVALID_PASSWORD', 'EMAIL_ALREADY_REGISTERED') */
+  code?: string;
+  /** HTTP status code */
+  status: number;
+  /** HTTP status text */
+  statusText: string;
+  constructor(authError: {
+    message?: string;
+    status: number;
+    statusText: string;
+    code?: string;
+  });
+}
+/**
+ * Type guard to check if an error is an AuthMutationError.
+ */
+declare function isAuthMutationError(error: unknown): error is AuthMutationError;
+//#endregion
 //#region src/crpc/error.d.ts
 /**
  * Client error codes (subset of CRPC codes for client-side use)
@@ -40,7 +69,7 @@ declare const defaultIsUnauthorized: (error: unknown) => boolean;
  */
 declare function convexQuery<T extends FunctionReference<'query'>>(funcRef: T, args?: FunctionArgs<T> | 'skip', meta?: Meta, opts?: {
   skipUnauth?: boolean;
-}): ConvexQueryOptions<T> & {
+}): BaseConvexQueryOptions<T> & {
   meta: ConvexQueryMeta;
 };
 /**
@@ -62,7 +91,7 @@ declare function convexQuery<T extends FunctionReference<'query'>>(funcRef: T, a
  */
 declare function convexAction<T extends FunctionReference<'action'>>(funcRef: T, args?: FunctionArgs<T> | 'skip', meta?: Meta, opts?: {
   skipUnauth?: boolean;
-}): ConvexActionOptions<T> & {
+}): BaseConvexActionOptions<T> & {
   meta: ConvexQueryMeta;
 };
 /**
@@ -71,6 +100,6 @@ declare function convexAction<T extends FunctionReference<'action'>>(funcRef: T,
  *
  * Uses flat { cursor, limit } input like tRPC.
  */
-declare function convexInfiniteQueryOptions<T extends FunctionReference<'query'>>(funcRef: T, args: Record<string, unknown> | 'skip', opts?: InfiniteQueryOptsParam<T>, meta?: Meta): ConvexInfiniteQueryOptions<T>;
+declare function convexInfiniteQueryOptions<T extends FunctionReference<'query'>>(funcRef: T, args: Record<string, unknown> | 'skip', opts?: BaseInfiniteQueryOptsParam<T> & Record<string, unknown>, meta?: Meta): BaseConvexInfiniteQueryOptions<T> & Record<string, unknown>;
 //#endregion
-export { AuthType, CRPCClient, CRPCClientError, CombinedDataTransformer, ConvexActionKey, ConvexActionOptions, ConvexInfiniteQueryMeta, ConvexInfiniteQueryOptions, ConvexInfiniteQueryOptionsWithRef, ConvexMutationKey, ConvexQueryHookOptions, ConvexQueryKey, ConvexQueryMeta, ConvexQueryOptions, DATE_CODEC_TAG, DataTransformer, DataTransformerOptions, DecorateAction, DecorateInfiniteQuery, DecorateMutation, DecorateQuery, ExtractPaginatedItem, FUNC_REF_SYMBOL, FnMeta, HttpClient, HttpClientError, HttpClientFromRouter, HttpErrorCode, HttpProcedureCall, HttpRouteInfo, HttpRouteMap, InferHttpInput, InferHttpOutput, InfiniteQueryInput, InfiniteQueryOptsParam, Meta, PaginatedFnMeta, PaginationOpts, VanillaAction, VanillaCRPCClient, VanillaMutation, VanillaQuery, WireCodec, convexAction, convexInfiniteQueryOptions, convexQuery, createTaggedTransformer, dateWireCodec, decodeWire, defaultCRPCTransformer, defaultIsUnauthorized, encodeWire, getTransformer, identityTransformer, isCRPCClientError, isCRPCError, isCRPCErrorCode, isHttpClientError };
+export { AuthMutationError, AuthType, BaseConvexActionOptions, BaseConvexInfiniteQueryOptions, BaseConvexQueryOptions, BaseInfiniteQueryOptsParam, CRPCClientError, CombinedDataTransformer, ConvexActionKey, ConvexInfiniteQueryMeta, ConvexMutationKey, ConvexQueryHookOptions, ConvexQueryKey, ConvexQueryMeta, DATE_CODEC_TAG, DataTransformer, DataTransformerOptions, EmptyObject, ExtractPaginatedItem, FUNC_REF_SYMBOL, FnMeta, HttpClient, HttpClientError, HttpClientFromRouter, HttpClientOptions, HttpErrorCode, HttpFormValue, HttpInputArgs, HttpProcedureCall, HttpProxyBaseOptions, HttpRouteInfo, HttpRouteMap, InferHttpInput, InferHttpOutput, InfiniteQueryInput, IsPaginated, Meta, MutationVariables, PaginatedFnMeta, PaginationOpts, RESERVED_KEYS, ReservedInfiniteQueryOptions, ReservedMutationOptions, ReservedQueryOptions, StaticQueryOptsParam, VanillaAction, VanillaMutation, WireCodec, buildSearchParams, convexAction, convexInfiniteQueryOptions, convexQuery, createTaggedTransformer, dateWireCodec, decodeWire, defaultCRPCTransformer, defaultIsUnauthorized, encodeWire, executeHttpRequest, getTransformer, identityTransformer, isAuthMutationError, isCRPCClientError, isCRPCError, isCRPCErrorCode, isHttpClientError, replaceUrlParam };

package/dist/crpc/index.js

@@ -2,6 +2,39 @@ import { a as isCRPCErrorCode, i as isCRPCError, n as defaultIsUnauthorized, r a
 import { a as defaultCRPCTransformer, c as identityTransformer, i as decodeWire, n as createTaggedTransformer, o as encodeWire, r as dateWireCodec, s as getTransformer, t as DATE_CODEC_TAG } from "../transformer-ogg-4d78.js";
 import { n as convexInfiniteQueryOptions, r as convexQuery, t as convexAction } from "../query-options-CSCmKYdJ.js";
 
+//#region src/crpc/auth-error.ts
+/**
+* Auth Mutation Error
+*
+* Framework-agnostic error class for Better Auth mutations.
+*/
+/**
+* Error thrown when a Better Auth mutation fails.
+* Contains the original error details from Better Auth.
+*/
+var AuthMutationError = class extends Error {
+	/** Error code from Better Auth (e.g., 'INVALID_PASSWORD', 'EMAIL_ALREADY_REGISTERED') */
+	code;
+	/** HTTP status code */
+	status;
+	/** HTTP status text */
+	statusText;
+	constructor(authError) {
+		super(authError.message || authError.statusText);
+		this.name = "AuthMutationError";
+		this.code = authError.code;
+		this.status = authError.status;
+		this.statusText = authError.statusText;
+	}
+};
+/**
+* Type guard to check if an error is an AuthMutationError.
+*/
+function isAuthMutationError(error) {
+	return error instanceof AuthMutationError;
+}
+
+//#endregion
 //#region src/crpc/http-types.ts
 /** HTTP client error */
 var HttpClientError = class extends Error {
@@ -19,10 +52,118 @@ var HttpClientError = class extends Error {
 /** Type guard for HttpClientError */
 const isHttpClientError = (error) => error instanceof HttpClientError;
 
+//#endregion
+//#region src/crpc/http-client.ts
+/**
+* HTTP Client Helpers
+*
+* Framework-agnostic utilities for executing HTTP requests
+* against Convex HTTP endpoints.
+*/
+/** Reserved keys that are not part of JSON body */
+const RESERVED_KEYS = new Set([
+	"params",
+	"searchParams",
+	"form",
+	"fetch",
+	"init",
+	"headers"
+]);
+/**
+* Replace URL path parameters with actual values.
+* e.g., '/users/:id' with { id: '123' } -> '/users/123'
+*/
+function replaceUrlParam(url, params) {
+	return url.replace(/:(\w+)/g, (_, key) => {
+		const value = params[key];
+		return value !== void 0 ? encodeURIComponent(value) : `:${key}`;
+	});
+}
+/**
+* Build URLSearchParams from query object.
+* Handles array values as multiple params with same key (like Hono).
+*/
+function buildSearchParams(query) {
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) if (Array.isArray(value)) for (const v of value) params.append(key, v);
+	else if (value !== void 0 && value !== null) params.append(key, value);
+	return params;
+}
+/**
+* Hono-style HTTP request executor.
+* Processes args in the same way as Hono's ClientRequestImpl.fetch().
+*/
+async function executeHttpRequest(opts) {
+	const { method, path } = opts.route;
+	const args = opts.args ?? {};
+	let rBody;
+	let cType;
+	if (args.form) {
+		const form = new FormData();
+		for (const [k, v] of Object.entries(args.form)) if (Array.isArray(v)) for (const v2 of v) form.append(k, v2);
+		else form.append(k, v);
+		rBody = form;
+	} else {
+		const jsonBody = {};
+		for (const [key, value] of Object.entries(args)) if (!RESERVED_KEYS.has(key) && value !== void 0) jsonBody[key] = value;
+		if (Object.keys(jsonBody).length > 0) {
+			rBody = JSON.stringify(opts.transformer.input.serialize(jsonBody));
+			cType = "application/json";
+		}
+	}
+	const argsClientOpts = {};
+	if (args.fetch) argsClientOpts.fetch = args.fetch;
+	if (args.init) argsClientOpts.init = args.init;
+	if (args.headers) argsClientOpts.headers = args.headers;
+	const mergedClientOpts = {
+		...opts.clientOpts,
+		...argsClientOpts
+	};
+	const resolvedBaseHeaders = typeof opts.baseHeaders === "function" ? await opts.baseHeaders() : opts.baseHeaders;
+	const headerValues = { ...typeof mergedClientOpts.headers === "function" ? await mergedClientOpts.headers() : mergedClientOpts.headers };
+	if (cType) headerValues["Content-Type"] = cType;
+	const finalHeaders = {};
+	if (resolvedBaseHeaders) {
+		for (const [key, value] of Object.entries(resolvedBaseHeaders)) if (value !== void 0) finalHeaders[key] = value;
+	}
+	Object.assign(finalHeaders, headerValues);
+	let url = opts.convexSiteUrl + path;
+	if (args.params) url = opts.convexSiteUrl + replaceUrlParam(path, args.params);
+	if (args.searchParams) {
+		const queryString = buildSearchParams(args.searchParams).toString();
+		if (queryString) url = `${url}?${queryString}`;
+	}
+	const methodUpperCase = method.toUpperCase();
+	const setBody = !(methodUpperCase === "GET" || methodUpperCase === "HEAD");
+	const response = await (mergedClientOpts.fetch ?? opts.baseFetch ?? globalThis.fetch)(url, {
+		body: setBody ? rBody : void 0,
+		method: methodUpperCase,
+		headers: finalHeaders,
+		...mergedClientOpts.init
+	});
+	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;
+	if ((response.headers.get("content-type") || "").includes("application/json")) return opts.transformer.output.deserialize(await response.json());
+	return response.text();
+}
+
 //#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, DATE_CODEC_TAG, FUNC_REF_SYMBOL, HttpClientError, convexAction, convexInfiniteQueryOptions, convexQuery, createTaggedTransformer, dateWireCodec, decodeWire, defaultCRPCTransformer, defaultIsUnauthorized, encodeWire, getTransformer, identityTransformer, isCRPCClientError, isCRPCError, isCRPCErrorCode, isHttpClientError };
+export { AuthMutationError, CRPCClientError, DATE_CODEC_TAG, FUNC_REF_SYMBOL, HttpClientError, RESERVED_KEYS, buildSearchParams, convexAction, convexInfiniteQueryOptions, convexQuery, createTaggedTransformer, dateWireCodec, decodeWire, defaultCRPCTransformer, defaultIsUnauthorized, encodeWire, executeHttpRequest, getTransformer, identityTransformer, isAuthMutationError, isCRPCClientError, isCRPCError, isCRPCErrorCode, isHttpClientError, replaceUrlParam };

package/dist/orm/index.d.ts

@@ -1,5 +1,5 @@
 import { i as pretendRequired, n as deprecated, r as pretend } from "../validators-BcQFm1oY.js";
-import { $ as DatabaseWithQuery, $n as BuildRelationResult, $r as notInArray, $t as defineRelationsPart, A as MigrationRunArgs, An as aggregateIndex, Ar as FieldReference, At as json, B as MigrationMigrateOne, Bn as ConvexUniqueConstraintBuilder, Br as gt, Bt as bigint, C as OrmBeforeResult, Cn as ConvexRankIndexBuilderOn, Cr as ReturningSelection, Ct as ConvexDateBuilderInitial, D as OrmTriggers, Dn as ConvexVectorIndexBuilder, Dr as unsetToken, Dt as ConvexCustomBuilderInitial, E as OrmTriggerContext, En as ConvexSearchIndexConfig, Er as VectorSearchProvider, Et as ConvexCustomBuilder, F as MigrationDirection, Fn as vectorIndex, Fr as between, Ft as ConvexBooleanBuilder, G as MigrationStep, Gn as unique, Gr as isNotNull, Gt as ManyConfig, H as MigrationRunStatus, Hn as ConvexUniqueConstraintConfig, Hr as ilike, Ht as CountBackfillKickoffArgs, I as MigrationDoc, In as ConvexCheckBuilder, Ir as contains, It as ConvexBooleanBuilderInitial, J as buildMigrationPlan, Jn as text, Jr as lt, Jt as RelationsBuilderColumnBase, K as MigrationTableName, Kn as ConvexTextBuilder, Kr as isNull, Kt as OneConfig, L as MigrationDocContext, Ln as ConvexCheckConfig, Lr as endsWith, Lt as boolean, M as MigrationStatusArgs, Mn as rankIndex, Mr as LogicalExpression, Mt as ConvexBytesBuilder, N as MigrationAppliedState, Nn as searchIndex, Nr as UnaryExpression, Nt as ConvexBytesBuilderInitial, O as defineTriggers, On as ConvexVectorIndexBuilderOn, Or as BinaryExpression, Ot as arrayOf, P as MigrationDefinition, Pn as uniqueIndex, Pr as and, Pt as bytes, Q as DatabaseWithMutations, Qn as BuildQueryResult, Qr as notBetween, Qt as defineRelations, R as MigrationDriftIssue, Rn as ConvexForeignKeyBuilder, Rr as eq, Rt as ConvexBigIntBuilder, S as scheduledDeleteFactory, Sn as ConvexRankIndexBuilder, Sr as ReturningResult, St as ConvexDateBuilder, T as OrmTriggerChange, Tn as ConvexSearchIndexBuilderOn, Tr as VectorQueryConfig, Tt as date, U as MigrationSet, Un as check, Ur as inArray, Ut as CountBackfillStatusArgs, V as MigrationPlan, Vn as ConvexUniqueConstraintBuilderOn, Vr as gte, Vt as CountBackfillChunkArgs, W as MigrationStateMap, Wn as foreignKey, Wr as isFieldReference, Wt as ExtractTablesWithRelations, X as defineMigrationSet, Xn as AggregateFieldValue, Xr as ne, Xt as TableRelationalConfig, Y as defineMigration, Yn as AggregateConfig, Yr as lte, Yt as RelationsBuilderColumnConfig, Z as detectMigrationDrift, Zn as AggregateResult, Zr as not, Zt as TablesRelationalConfig, _ as OrmWriterCtx, _i as IsPrimaryKey, _n as rlsRole, _r as OrderByClause, _t as ConvexNumberBuilderInitial, a as TableConfigResult, ai as OrmSchemaPluginTables, an as OrmLifecycleChange, ar as InferInsertModel, at as extractRelationsConfig, b as scheduledMutationBatchFactory, bn as ConvexIndexBuilder, br as PredicateWhereIndexConfig, bt as ConvexIdBuilderInitial, c as OrmNotFoundError, ci as AnyColumn, cn as convexTable, cr as InsertValue, ct as vector, d as GenericOrmCtx, di as ColumnBuilderRuntimeConfig, dn as RlsPolicy, dr as MutationExecutionMode, dt as ConvexTimestampMode, ei as or, en as ConvexDeletionBuilder, er as CountConfig, et as OrmReader, f as OrmApiResult, fi as ColumnBuilderTypeConfig, fn as RlsPolicyConfig, fr as MutationPaginateConfig, ft as timestamp, g as OrmReaderCtx, gi as HasDefault, gn as RlsRoleConfig, gr as MutationRunMode, gt as ConvexNumberBuilder, h as OrmFunctions, hi as DrizzleEntity, hn as RlsRole, hr as MutationReturning, ht as textEnum, i as desc, ii as OrmSchemaPlugin, in as DiscriminatorBuilderConfig, ir as GetColumnData, it as EdgeMetadata, j as MigrationRunChunkArgs, jn as index, jr as FilterExpression, jt as objectOf, k as MigrationCancelArgs, kn as ConvexVectorIndexConfig, kr as ExpressionVisitor, kt as custom, l as CreateOrmOptions, li as ColumnBuilder, ln as deletion, lr as MutationExecuteConfig, lt as ConvexTimestampBuilder, m as OrmClientWithApi, mi as ColumnDataType, mn as rlsPolicy, mr as MutationResult, mt as ConvexTextEnumBuilderInitial, n as defineSchema, ni as Brand, nn as ConvexTable, nr as DBQueryConfig, nt as RlsContext, o as getTableColumns, oi as TableName, on as OrmLifecycleOperation, or as InferModelFromColumns, ot as ConvexVectorBuilder, p as OrmClientBase, pi as ColumnBuilderWithTableName, pn as RlsPolicyToOption, pr as MutationPaginatedResult, pt as ConvexTextEnumBuilder, q as MigrationWriteMode, qn as ConvexTextBuilderInitial, qr as like, qt as RelationsBuilder, r as asc, ri as Columns, rr as FilterOperators, rt as RlsMode, s as getTableConfig, si as SystemFields, sn as TableConfig, sr as InferSelectModel, st as ConvexVectorBuilderInitial, t as WhereClauseResult, ti as startsWith, tn as ConvexDeletionConfig, tr as CountResult, tt as OrmWriter, u as GenericOrm, ui as ColumnBuilderBaseConfig, un as discriminator, ur as MutationExecuteResult, ut as ConvexTimestampBuilderInitial, v as createOrm, vi as IsUnique, vn as ConvexAggregateIndexBuilder, vr as OrderDirection, vt as integer, w as OrmTableTriggers, wn as ConvexSearchIndexBuilder, wr as UpdateSet, wt as ConvexDateMode, x as ScheduledDeleteArgs, xn as ConvexIndexBuilderOn, xr as ReturningAll, xt as id, y as ScheduledMutationBatchArgs, yi as NotNull, yn as ConvexAggregateIndexBuilderOn, yr as PaginatedResult, yt as ConvexIdBuilder, z as MigrationManifestEntry, zn as ConvexForeignKeyConfig, zr as fieldRef, zt as ConvexBigIntBuilderInitial } from "../where-clause-compiler-UavDdMUX.js";
+import { $ as DatabaseWithMutations, $n as BuildQueryResult, $r as notBetween, $t as defineRelations, A as MigrationCancelArgs, An as ConvexVectorIndexConfig, Ar as ExpressionVisitor, At as custom, B as MigrationManifestEntry, Bn as ConvexForeignKeyConfig, Br as fieldRef, Bt as ConvexBigIntBuilderInitial, C as OrmBeforeResult, Cn as ConvexRankIndexBuilder, Cr as ReturningResult, Ct as ConvexDateBuilder, D as OrmTriggers, Dn as ConvexSearchIndexConfig, Dr as VectorSearchProvider, Dt as ConvexCustomBuilder, E as OrmTriggerContext, En as ConvexSearchIndexBuilderOn, Er as VectorQueryConfig, Et as date, F as MigrationDefinition, Fn as uniqueIndex, Fr as and, Ft as bytes, G as MigrationStateMap, Gn as foreignKey, Gr as isFieldReference, Gt as ExtractTablesWithRelations, H as MigrationPlan, Hn as ConvexUniqueConstraintBuilderOn, Hr as gte, Ht as CountBackfillChunkArgs, I as MigrationDirection, In as vectorIndex, Ir as between, It as ConvexBooleanBuilder, J as MigrationWriteMode, Jn as ConvexTextBuilderInitial, Jr as like, Jt as RelationsBuilder, K as MigrationStep, Kn as unique, Kr as isNotNull, Kt as ManyConfig, L as MigrationDoc, Ln as ConvexCheckBuilder, Lr as contains, Lt as ConvexBooleanBuilderInitial, M as MigrationRunChunkArgs, Mn as index, Mr as FilterExpression, Mt as objectOf, N as MigrationStatusArgs, Nn as rankIndex, Nr as LogicalExpression, Nt as ConvexBytesBuilder, O as defineTriggers, On as ConvexVectorIndexBuilder, Or as unsetToken, Ot as ConvexCustomBuilderInitial, P as MigrationAppliedState, Pn as searchIndex, Pr as UnaryExpression, Pt as ConvexBytesBuilderInitial, Q as detectMigrationDrift, Qn as AggregateResult, Qr as not, Qt as TablesRelationalConfig, R as MigrationDocContext, Rn as ConvexCheckConfig, Rr as endsWith, Rt as boolean, S as scheduledDeleteFactory, Sn as ConvexIndexBuilderOn, Sr as ReturningAll, St as id, T as OrmTriggerChange, Tn as ConvexSearchIndexBuilder, Tr as UpdateSet, Tt as ConvexDateMode, U as MigrationRunStatus, Un as ConvexUniqueConstraintConfig, Ur as ilike, Ut as CountBackfillKickoffArgs, V as MigrationMigrateOne, Vn as ConvexUniqueConstraintBuilder, Vr as gt, Vt as bigint, W as MigrationSet, Wn as check, Wr as inArray, Wt as CountBackfillStatusArgs, X as defineMigration, Xn as AggregateConfig, Xr as lte, Xt as RelationsBuilderColumnConfig, Y as buildMigrationPlan, Yn as text, Yr as lt, Yt as RelationsBuilderColumnBase, Z as defineMigrationSet, Zn as AggregateFieldValue, Zr as ne, Zt as TableRelationalConfig, _ as OrmWriterCtx, _i as HasDefault, _n as RlsRoleConfig, _r as MutationRunMode, _t as ConvexNumberBuilder, a as TableConfigResult, ai as OrmSchemaPlugin, an as DiscriminatorBuilderConfig, ar as GetColumnData, at as EdgeMetadata, b as scheduledMutationBatchFactory, bi as NotNull, bn as ConvexAggregateIndexBuilderOn, br as PaginatedResult, bt as ConvexIdBuilder, c as OrmNotFoundError, ci as SystemFields, cn as TableConfig, cr as InferSelectModel, ct as ConvexVectorBuilderInitial, d as GenericOrmCtx, di as ColumnBuilderBaseConfig, dn as discriminator, dr as MutationExecuteResult, dt as ConvexTimestampBuilderInitial, ei as notInArray, en as defineRelationsPart, er as BuildRelationResult, et as DatabaseWithQuery, f as OrmApiResult, fi as ColumnBuilderRuntimeConfig, fn as RlsPolicy, fr as MutationExecutionMode, ft as ConvexTimestampMode, g as OrmReaderCtx, gi as DrizzleEntity, gn as RlsRole, gr as MutationReturning, gt as textEnum, h as OrmFunctions, hi as ColumnDataType, hn as rlsPolicy, hr as MutationResult, ht as ConvexTextEnumBuilderInitial, i as desc, ii as Columns, ir as FilterOperators, it as RlsMode, j as MigrationRunArgs, jn as aggregateIndex, jr as FieldReference, jt as json, kn as ConvexVectorIndexBuilderOn, kr as BinaryExpression, kt as arrayOf, l as CreateOrmOptions, li as AnyColumn, ln as convexTable, lr as InsertValue, lt as vector, m as OrmClientWithApi, mi as ColumnBuilderWithTableName, mn as RlsPolicyToOption, mr as MutationPaginatedResult, mt as ConvexTextEnumBuilder, n as defineSchema, ni as startsWith, nn as ConvexDeletionConfig, nr as CountResult, nt as OrmWriter, o as getTableColumns, oi as OrmSchemaPluginTables, on as OrmLifecycleChange, or as InferInsertModel, ot as extractRelationsConfig, p as OrmClientBase, pi as ColumnBuilderTypeConfig, pn as RlsPolicyConfig, pr as MutationPaginateConfig, pt as timestamp, q as MigrationTableName, qn as ConvexTextBuilder, qr as isNull, qt as OneConfig, r as asc, ri as Brand, rn as ConvexTable, rr as DBQueryConfig, rt as RlsContext, s as getTableConfig, si as TableName, sn as OrmLifecycleOperation, sr as InferModelFromColumns, st as ConvexVectorBuilder, t as WhereClauseResult, ti as or, tn as ConvexDeletionBuilder, tr as CountConfig, tt as OrmReader, u as GenericOrm, ui as ColumnBuilder, un as deletion, ur as MutationExecuteConfig, ut as ConvexTimestampBuilder, v as createOrm, vi as IsPrimaryKey, vn as rlsRole, vr as OrderByClause, vt as ConvexNumberBuilderInitial, w as OrmTableTriggers, wn as ConvexRankIndexBuilderOn, wr as ReturningSelection, wt as ConvexDateBuilderInitial, x as ScheduledDeleteArgs, xn as ConvexIndexBuilder, xr as PredicateWhereIndexConfig, xt as ConvexIdBuilderInitial, y as ScheduledMutationBatchArgs, yi as IsUnique, yn as ConvexAggregateIndexBuilder, yr as OrderDirection, yt as integer, z as MigrationDriftIssue, zn as ConvexForeignKeyBuilder, zr as eq, zt as ConvexBigIntBuilder } from "../where-clause-compiler-DjFwXrQn.js";
 import { a as QueryCtxWithPreferredOrmQueryTable, i as QueryCtxWithOrmQueryTable, n as LookupByIdResultByCtx, o as getByIdWithOrmQueryFallback, r as QueryCtxWithOptionalOrmQueryTable, t as DocByCtx } from "../query-context-ji7By8u0.js";
 import { DefineSchemaOptions, GenericSchema, SchemaDefinition } from "convex/server";
 export { type AggregateConfig, type AggregateFieldValue, type AggregateResult, type AnyColumn, type BinaryExpression, Brand, type BuildQueryResult, type BuildRelationResult, type ColumnBuilder, type ColumnBuilderBaseConfig, type ColumnBuilderRuntimeConfig, type ColumnBuilderTypeConfig, type ColumnBuilderWithTableName, type ColumnDataType, Columns, type ConvexAggregateIndexBuilder, type ConvexAggregateIndexBuilderOn, type ConvexBigIntBuilder, type ConvexBigIntBuilderInitial, type ConvexBooleanBuilder, type ConvexBooleanBuilderInitial, type ConvexBytesBuilder, type ConvexBytesBuilderInitial, type ConvexCheckBuilder, type ConvexCheckConfig, type ConvexCustomBuilder, type ConvexCustomBuilderInitial, type ConvexDateBuilder, type ConvexDateBuilderInitial, type ConvexDateMode, type ConvexDeletionBuilder, type ConvexDeletionConfig, type ConvexForeignKeyBuilder, type ConvexForeignKeyConfig, type ConvexIdBuilder, type ConvexIdBuilderInitial, type ConvexIndexBuilder, type ConvexIndexBuilderOn, type ConvexNumberBuilder, type ConvexNumberBuilderInitial, type ConvexRankIndexBuilder, type ConvexRankIndexBuilderOn, type ConvexSearchIndexBuilder, type ConvexSearchIndexBuilderOn, type ConvexSearchIndexConfig, type ConvexTable, type ConvexTextBuilder, type ConvexTextBuilderInitial, type ConvexTextEnumBuilder, type ConvexTextEnumBuilderInitial, type ConvexTimestampBuilder, type ConvexTimestampBuilderInitial, type ConvexTimestampMode, type ConvexUniqueConstraintBuilder, type ConvexUniqueConstraintBuilderOn, type ConvexUniqueConstraintConfig, type ConvexVectorBuilder, type ConvexVectorBuilderInitial, type ConvexVectorIndexBuilder, type ConvexVectorIndexBuilderOn, type ConvexVectorIndexConfig, type CountBackfillChunkArgs, type CountBackfillKickoffArgs, type CountBackfillStatusArgs, type CountConfig, type CountResult, type CreateOrmOptions, type DBQueryConfig, type DatabaseWithMutations, type DatabaseWithQuery, type DefineSchemaOptions, type DiscriminatorBuilderConfig, type DocByCtx, type DrizzleEntity, type EdgeMetadata, type ExpressionVisitor, type ExtractTablesWithRelations, type FieldReference, type FilterExpression, type FilterOperators, type GenericOrm, type GenericOrmCtx, type GenericSchema, type GetColumnData, type HasDefault, type InferInsertModel, type InferModelFromColumns, type InferSelectModel, type InsertValue, type IsPrimaryKey, type IsUnique, type LogicalExpression, type LookupByIdResultByCtx, type ManyConfig, type MigrationAppliedState, type MigrationCancelArgs, type MigrationDefinition, type MigrationDirection, type MigrationDoc, type MigrationDocContext, type MigrationDriftIssue, type MigrationManifestEntry, type MigrationMigrateOne, type MigrationPlan, type MigrationRunArgs, type MigrationRunChunkArgs, type MigrationRunStatus, type MigrationSet, type MigrationStateMap, type MigrationStatusArgs, type MigrationStep, type MigrationTableName, type MigrationWriteMode, type MutationExecuteConfig, type MutationExecuteResult, type MutationExecutionMode, type MutationPaginateConfig, type MutationPaginatedResult, type MutationResult, type MutationReturning, type MutationRunMode, type NotNull, type OneConfig, type OrderByClause, type OrderDirection, type OrmApiResult, type OrmBeforeResult, type OrmClientBase, type OrmClientWithApi, type OrmFunctions, type OrmLifecycleChange, type OrmLifecycleOperation, OrmNotFoundError, type OrmReader, type OrmReaderCtx, type OrmSchemaPlugin, OrmSchemaPluginTables, type OrmTableTriggers, type OrmTriggerChange, type OrmTriggerContext, type OrmTriggers, type OrmWriter, type OrmWriterCtx, type PaginatedResult, type PredicateWhereIndexConfig, type QueryCtxWithOptionalOrmQueryTable, type QueryCtxWithOrmQueryTable, type QueryCtxWithPreferredOrmQueryTable, type RelationsBuilder, type RelationsBuilderColumnBase, type RelationsBuilderColumnConfig, type ReturningAll, type ReturningResult, type ReturningSelection, type RlsContext, type RlsMode, RlsPolicy, type RlsPolicyConfig, type RlsPolicyToOption, RlsRole, type RlsRoleConfig, type ScheduledDeleteArgs, type ScheduledMutationBatchArgs, type SchemaDefinition, type SystemFields, type TableConfig, type TableConfigResult, TableName, type TableRelationalConfig, type TablesRelationalConfig, type UnaryExpression, type UpdateSet, type VectorQueryConfig, type VectorSearchProvider, type WhereClauseResult, aggregateIndex, and, arrayOf, asc, between, bigint, boolean, buildMigrationPlan, bytes, check, contains, convexTable, createOrm, custom, date, defineMigration, defineMigrationSet, defineRelations, defineRelationsPart, defineSchema, defineTriggers, deletion, deprecated, desc, detectMigrationDrift, discriminator, endsWith, eq, extractRelationsConfig, fieldRef, foreignKey, getByIdWithOrmQueryFallback, getTableColumns, getTableConfig, gt, gte, id, ilike, inArray, index, integer, isFieldReference, isNotNull, isNull, json, like, lt, lte, ne, not, notBetween, notInArray, objectOf, or, pretend, pretendRequired, rankIndex, rlsPolicy, rlsRole, scheduledDeleteFactory, scheduledMutationBatchFactory, searchIndex, startsWith, text, textEnum, timestamp, unique, uniqueIndex, unsetToken, vector, vectorIndex };

package/dist/orm/index.js

@@ -2075,6 +2075,12 @@ function findRelationIndex(table, columns, relationName, targetTableName, strict
 const PUBLIC_CREATED_AT_FIELD = "createdAt";
 const INTERNAL_CREATION_TIME_FIELD = "_creationTime";
 const CREATED_AT_MIGRATION_MESSAGE = "`_creationTime` is no longer public. Use `createdAt` instead.";
+const hasUserCreatedAtColumn = (table) => {
+	if (!table || typeof table !== "object") return false;
+	const columns = table[Columns];
+	if (!columns || typeof columns !== "object") return false;
+	return Object.hasOwn(columns, PUBLIC_CREATED_AT_FIELD);
+};
 const usesSystemCreatedAtAlias = (_table) => true;
 
 //#endregion
@@ -2176,10 +2182,11 @@ const normalizePublicSystemFields = (value, options) => {
 };
 const normalizeDateFieldsForWrite = (table, value) => {
 	const useSystemCreatedAt = usesSystemCreatedAtAlias(table);
+	const hasUserCreatedAt = hasUserCreatedAtColumn(table);
 	const temporalColumns = getTemporalColumnDescriptors(table);
 	const result = { ...value };
 	if (Object.hasOwn(result, INTERNAL_CREATION_TIME_FIELD)) throw new Error(CREATED_AT_MIGRATION_MESSAGE);
-	if (useSystemCreatedAt && Object.hasOwn(result, PUBLIC_CREATED_AT_FIELD)) delete result[PUBLIC_CREATED_AT_FIELD];
+	if (useSystemCreatedAt && !hasUserCreatedAt && Object.hasOwn(result, PUBLIC_CREATED_AT_FIELD)) delete result[PUBLIC_CREATED_AT_FIELD];
 	for (const [name, descriptor] of temporalColumns.entries()) {
 		if (!Object.hasOwn(result, name)) continue;
 		result[name] = normalizeTemporalWriteValue(descriptor, result[name]);