better-convex 0.5.7 → 0.6.0

package/dist/auth/index.d.ts

@@ -1,14 +1,15 @@
+import { t as GenericCtx } from "../context-utils-DSuX99Da.js";
+import { convex } from "@convex-dev/better-auth/plugins";
 import * as better_auth_adapters1 from "better-auth/adapters";
 import { DBAdapterDebugLogOption } from "better-auth/adapters";
 import { BetterAuthDBSchema } from "better-auth/db";
 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 { DocumentByName, FunctionReference, GenericDataModel, GenericMutationCtx, GenericQueryCtx, GenericSchema, HttpRouter, PaginationOptions, PaginationResult, SchemaDefinition, 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";
 import { SetOptional } from "type-fest";
 
 //#region src/auth/create-client.d.ts
@@ -27,38 +28,36 @@ type AuthFunctions = {
   beforeDelete?: FunctionReference<'mutation', 'internal', Record<string, any>>;
   beforeUpdate?: FunctionReference<'mutation', 'internal', Record<string, any>>;
 };
-type Triggers<DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>> = { [K in keyof Schema['tables'] & string]?: {
-  beforeCreate?: (ctx: GenericMutationCtx<DataModel>, data: Infer<Schema['tables'][K]['validator']>) => Promise<Infer<Schema['tables'][K]['validator']> | undefined>;
-  beforeDelete?: (ctx: GenericMutationCtx<DataModel>, doc: Infer<Schema['tables'][K]['validator']> & IdField<K> & SystemFields) => Promise<(Infer<Schema['tables'][K]['validator']> & IdField<K> & SystemFields) | undefined>;
-  beforeUpdate?: (ctx: GenericMutationCtx<DataModel>, doc: Infer<Schema['tables'][K]['validator']> & IdField<K> & SystemFields, update: Partial<Infer<Schema['tables'][K]['validator']>>) => Promise<Partial<Infer<Schema['tables'][K]['validator']>> | undefined>;
-  onCreate?: (ctx: GenericMutationCtx<DataModel>, doc: Infer<Schema['tables'][K]['validator']> & IdField<K> & SystemFields) => Promise<void>;
-  onDelete?: (ctx: GenericMutationCtx<DataModel>, doc: Infer<Schema['tables'][K]['validator']> & IdField<K> & SystemFields) => Promise<void>;
-  onUpdate?: (ctx: GenericMutationCtx<DataModel>, newDoc: Infer<Schema['tables'][K]['validator']> & IdField<K> & {
-    _creationTime: number;
-  }, oldDoc: Infer<Schema['tables'][K]['validator']> & IdField<K> & SystemFields) => Promise<void>;
+type Triggers<DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>, TriggerCtx extends GenericMutationCtx<DataModel> = GenericMutationCtx<DataModel>> = { [K in Extract<keyof Schema['tables'] & string, TableNamesInDataModel<DataModel>>]?: {
+  beforeCreate?: (ctx: TriggerCtx, data: Omit<DocumentByName<DataModel, K>, '_id' | '_creationTime'>) => Promise<Omit<DocumentByName<DataModel, K>, '_id' | '_creationTime'> | undefined>;
+  beforeDelete?: (ctx: TriggerCtx, doc: DocumentByName<DataModel, K>) => Promise<DocumentByName<DataModel, K> | undefined>;
+  beforeUpdate?: (ctx: TriggerCtx, doc: DocumentByName<DataModel, K>, update: Partial<Omit<DocumentByName<DataModel, K>, '_id' | '_creationTime'>>) => Promise<Partial<Omit<DocumentByName<DataModel, K>, '_id' | '_creationTime'>> | undefined>;
+  onCreate?: (ctx: TriggerCtx, doc: DocumentByName<DataModel, K>) => Promise<void>;
+  onDelete?: (ctx: TriggerCtx, doc: DocumentByName<DataModel, K>) => Promise<void>;
+  onUpdate?: (ctx: TriggerCtx, newDoc: DocumentByName<DataModel, K>, oldDoc: DocumentByName<DataModel, K>) => Promise<void>;
 } };
-declare const createClient: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true>>(config: {
+declare const createClient: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<GenericSchema, true>, TriggerCtx extends GenericMutationCtx<DataModel> = GenericMutationCtx<DataModel>>(config: {
   authFunctions: AuthFunctions;
   schema: Schema;
   internalMutation?: typeof internalMutationGeneric;
-  triggers?: Triggers<DataModel, Schema>;
+  context?: (ctx: GenericMutationCtx<DataModel>) => TriggerCtx | Promise<TriggerCtx>;
+  triggers?: Triggers<DataModel, Schema, TriggerCtx>;
 }) => {
   authFunctions: AuthFunctions;
-  triggers: Triggers<DataModel, Schema> | undefined;
-  adapter: (ctx: GenericCtx<DataModel>, createAuthOptions: (ctx: any) => BetterAuthOptions) => better_auth_adapters1.AdapterFactory;
-  httpAdapter: (ctx: GenericCtx<DataModel>) => better_auth_adapters1.AdapterFactory;
+  triggers: Triggers<DataModel, Schema, TriggerCtx> | undefined;
+  adapter: (ctx: GenericCtx<DataModel>, getAuthOptions: (ctx: any) => BetterAuthOptions) => better_auth_adapters1.AdapterFactory;
   triggersApi: () => {
     beforeCreate: convex_server24.RegisteredMutation<"internal", {
-      model: string;
       data: any;
+      model: string;
     }, Promise<any>>;
     beforeDelete: convex_server24.RegisteredMutation<"internal", {
       model: string;
       doc: any;
     }, Promise<any>>;
     beforeUpdate: convex_server24.RegisteredMutation<"internal", {
-      model: string;
       update: any;
+      model: string;
       doc: any;
     }, Promise<any>>;
     onCreate: convex_server24.RegisteredMutation<"internal", {
@@ -125,7 +124,7 @@ declare const adapterConfig: {
     field: string;
     action: "create" | "update" | "findOne" | "findMany" | "updateMany" | "delete" | "deleteMany" | "count";
     model: string;
-    schema: better_auth0.BetterAuthDBSchema;
+    schema: BetterAuthDBSchema;
     options: BetterAuthOptions;
   }) => any;
   customTransformOutput: ({
@@ -137,20 +136,22 @@ declare const adapterConfig: {
     field: string;
     select: string[];
     model: string;
-    schema: better_auth0.BetterAuthDBSchema;
+    schema: BetterAuthDBSchema;
     options: BetterAuthOptions;
   }) => any;
 };
 declare const httpAdapter: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>>(ctx: GenericCtx<DataModel>, {
   authFunctions,
   debugLogs,
+  schema,
   triggers
 }: {
   authFunctions: AuthFunctions;
   debugLogs?: DBAdapterDebugLogOption;
+  schema?: Schema;
   triggers?: Triggers<DataModel, Schema>;
 }) => better_auth_adapters1.AdapterFactory;
-declare const dbAdapter: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>>(ctx: GenericCtx<DataModel>, createAuthOptions: (ctx: any) => BetterAuthOptions, {
+declare const dbAdapter: <DataModel extends GenericDataModel, Schema extends SchemaDefinition<any, any>>(ctx: GenericCtx<DataModel>, getAuthOptions: (ctx: any) => BetterAuthOptions, {
   authFunctions,
   debugLogs,
   schema,
@@ -163,6 +164,10 @@ declare const dbAdapter: <DataModel extends GenericDataModel, Schema extends Sch
 }) => better_auth_adapters1.AdapterFactory;
 //#endregion
 //#region src/auth/adapter-utils.d.ts
+type AdapterPaginationOptions = PaginationOptions & {
+  endCursor?: string | null;
+  maximumRowsRead?: number;
+};
 declare const adapterWhereValidator: convex_values0.VObject<{
   connector?: "AND" | "OR" | undefined;
   operator?: "lt" | "lte" | "gt" | "gte" | "eq" | "in" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
@@ -176,8 +181,8 @@ declare const adapterWhereValidator: convex_values0.VObject<{
 }, "required", "connector" | "field" | "operator" | "value">;
 declare const adapterArgsValidator: convex_values0.VObject<{
   limit?: number | undefined;
-  offset?: number | undefined;
   select?: string[] | undefined;
+  offset?: number | undefined;
   sortBy?: {
     field: string;
     direction: "asc" | "desc";
@@ -217,17 +222,17 @@ declare const adapterArgsValidator: convex_values0.VObject<{
     operator: convex_values0.VUnion<"lt" | "lte" | "gt" | "gte" | "eq" | "in" | "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", "connector" | "field" | "operator" | "value">, "optional">;
-}, "required", "limit" | "model" | "offset" | "select" | "sortBy" | "where" | "sortBy.field" | "sortBy.direction">;
+}, "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>;
 declare const paginate: <Doc extends DocumentByName<GenericDataModel, T>, T extends TableNamesInDataModel<GenericDataModel>>(ctx: GenericQueryCtx<GenericDataModel>, schema: SchemaDefinition<any, any>, betterAuthSchema: BetterAuthDBSchema, args: Infer<typeof adapterArgsValidator> & {
-  paginationOpts: PaginationOptions;
+  paginationOpts: AdapterPaginationOptions;
 }) => Promise<PaginationResult<Doc>>;
 declare const listOne: <Doc extends DocumentByName<GenericDataModel, T>, T extends TableNamesInDataModel<GenericDataModel>>(ctx: GenericQueryCtx<GenericDataModel>, schema: SchemaDefinition<any, any>, betterAuthSchema: BetterAuthDBSchema, args: Infer<typeof adapterArgsValidator>) => Promise<Doc | null>;
 //#endregion
 //#region src/auth/types.d.ts
-type CreateAuth = (ctx: any) => ReturnType<typeof betterAuth>;
+type GetAuth = (ctx: any) => ReturnType<typeof betterAuth>;
 //#endregion
 //#region src/auth/create-api.d.ts
 type Schema = SchemaDefinition<any, any>;
@@ -309,8 +314,9 @@ declare const deleteManyHandler: (ctx: any, args: {
   splitCursor?: convex_server24.Cursor | null;
   pageStatus?: "SplitRecommended" | "SplitRequired" | null;
 }>;
-declare const createApi: <Schema extends SchemaDefinition<any, any>>(schema: Schema, createAuth: CreateAuth, options?: {
-  internalMutation?: typeof internalMutationGeneric; /** Skip input validation for smaller generated types. Since these are internal functions, validation is optional. */
+declare const createApi: <Schema extends SchemaDefinition<any, any>>(schema: Schema, getAuth: GetAuth, options?: {
+  internalMutation?: typeof internalMutationGeneric;
+  context?: (ctx: any) => any | Promise<any>; /** Skip input validation for smaller generated types. Since these are internal functions, validation is optional. */
   skipValidation?: boolean;
 }) => {
   create: convex_server24.RegisteredMutation<"internal", {
@@ -318,15 +324,15 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>>(schema: Sch
     beforeCreateHandle?: string | undefined;
     onCreateHandle?: string | undefined;
     input: {
-      model: string;
       data: any;
-    } | {
       model: string;
+    } | {
       data: {
         [x: string]: unknown;
         [x: number]: unknown;
         [x: symbol]: unknown;
       };
+      model: string;
     };
   }, Promise<any>>;
   deleteMany: convex_server24.RegisteredMutation<"internal", {
@@ -377,8 +383,8 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>>(schema: Sch
     };
   }, Promise<convex_server24.GenericDocument | undefined>>;
   findMany: convex_server24.RegisteredQuery<"internal", {
-    join?: any;
     limit?: number | undefined;
+    join?: any;
     offset?: number | undefined;
     sortBy?: {
       field: string;
@@ -390,7 +396,6 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>>(schema: Sch
       field: string;
       value: string | number | boolean | string[] | number[] | null;
     }[] | undefined;
-    model: string;
     paginationOpts: {
       id?: number;
       endCursor?: string | null;
@@ -399,6 +404,7 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>>(schema: Sch
       numItems: number;
       cursor: string | null;
     };
+    model: string;
   }, Promise<convex_server24.PaginationResult<convex_server24.GenericDocument>>>;
   findOne: convex_server24.RegisteredQuery<"internal", {
     join?: any;
@@ -424,8 +430,8 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>>(schema: Sch
     };
     input: {
       where?: any[] | undefined;
-      model: string;
       update: any;
+      model: string;
     } | {
       where?: {
         connector?: "AND" | "OR" | undefined;
@@ -433,12 +439,12 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>>(schema: Sch
         field: string;
         value: string | number | boolean | string[] | number[] | null;
       }[] | undefined;
-      model: string;
       update: {
         [x: string]: unknown;
         [x: number]: unknown;
         [x: symbol]: unknown;
       };
+      model: string;
     };
   }, Promise<{
     count: number;
@@ -453,8 +459,8 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>>(schema: Sch
     onUpdateHandle?: string | undefined;
     input: {
       where?: any[] | undefined;
-      model: string;
       update: any;
+      model: string;
     } | {
       where?: {
         connector?: "AND" | "OR" | undefined;
@@ -462,12 +468,12 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>>(schema: Sch
         field: string;
         value: string | number | boolean | string[] | number[] | null;
       }[] | undefined;
-      model: string;
       update: {
         [x: string]: unknown;
         [x: number]: unknown;
         [x: symbol]: unknown;
       };
+      model: string;
     };
   }, Promise<any>>;
   getLatestJwks: convex_server24.RegisteredAction<"internal", {}, Promise<any>>;
@@ -522,11 +528,21 @@ interface AuthMiddlewareOptions {
  *
  * const app = new Hono();
  * app.use('/api/*', cors({ origin: process.env.SITE_URL, credentials: true }));
- * app.use(authMiddleware(createAuth));
+ * app.use(authMiddleware(getAuth));
  *
  * export default createHttpRouter(app, appRouter);
  * ```
  */
-declare function authMiddleware(createAuth: CreateAuth, opts?: AuthMiddlewareOptions): MiddlewareHandler;
+declare function authMiddleware(getAuth: GetAuth, opts?: AuthMiddlewareOptions): MiddlewareHandler;
+//#endregion
+//#region src/auth/registerRoutes.d.ts
+declare const registerRoutes: (http: HttpRouter, getAuth: GetAuth, opts?: {
+  cors?: {
+    allowedHeaders?: string[];
+    allowedOrigins?: string[];
+    exposedHeaders?: string[];
+  } | boolean;
+  verbose?: boolean;
+}) => void;
 //#endregion
-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 };
+export { type AuthFunctions, AuthMiddlewareOptions, ConvexCleanedWhere, GetAuth, adapterArgsValidator, adapterConfig, adapterWhereValidator, authMiddleware, checkUniqueFields, convex, createApi, createClient, createHandler, dbAdapter, deleteManyHandler, deleteOneHandler, findManyHandler, findOneHandler, getAuthUserId, getAuthUserIdentity, getHeaders, getSession, handlePagination, hasUniqueFields, httpAdapter, listOne, paginate, registerRoutes, selectFields, updateManyHandler, updateOneHandler };