@convex-dev/better-auth 0.9.11 → 0.10.0

package/dist/plugins/convex/index.d.ts

@@ -1,39 +1,122 @@
+import { type BetterAuthOptions, type Session, type User } from "better-auth";
+import type { AuthConfig } from "convex/server";
 export declare const JWT_COOKIE_NAME = "convex_jwt";
-export declare const convex: (opts?: {
-    jwtExpirationSeconds?: number;
-    deleteExpiredSessionsOnLogin?: boolean;
-    options?: {
-        basePath?: string;
+export declare const convex: (opts: {
+    /**
+     * @param {AuthConfig} authConfig - Auth config from your Convex project.
+     *
+     * Typically found in `convex/auth.config.ts`.
+     *
+     * @example
+     * ```ts
+     * // convex/auth.config.ts
+     * export default {
+     *   providers: [getAuthConfigProvider({ jwks: process.env.JWKS })],
+     * } satisfies AuthConfig;
+     * ```
+     *
+     * @example
+     * ```ts
+     * // convex/auth.ts
+     * import authConfig from './auth.config';
+     * export const createAuth = (ctx: GenericCtx<DataModel>) => {
+     *   return betterAuth({
+     *     // ...
+     *     plugins: [convex({ authConfig })],
+     *   });
+     * };
+     * ```
+     */
+    authConfig: AuthConfig;
+    /**
+     * @param {Object} jwt - JWT options.
+     * @param {number} jwt.expirationSeconds - JWT expiration seconds.
+     * @param {Function} jwt.definePayload - Function to define the JWT payload. `sessionId` and `iat` are added automatically.
+     */
+    jwt?: {
+        expirationSeconds?: number;
+        definePayload?: (session: {
+            user: User & Record<string, any>;
+            session: Session & Record<string, any>;
+        }) => Promise<Record<string, any>> | Record<string, any> | undefined;
     };
+    /**
+     * @deprecated Use jwt.expirationSeconds instead.
+     */
+    jwtExpirationSeconds?: number;
+    /**
+     * @param {string} jwks - Optional static JWKS to avoid fetching from the database.
+     *
+     * This should be a stringified document from the Better Auth JWKS table. You
+     * can create one in the console.
+     *
+     * @example
+     * ```ts
+     * // convex/auth.ts
+     * export const rotateKeys = internalAction({
+     *   args: {},
+     *   handler: async (ctx) => {
+     *     const auth = createAuth(ctx)
+     *     return await auth.api.rotateKeys()
+     *   },
+     * })
+     * ```
+     * Run the action and set the JWKS environment variable
+     *
+     * ```bash
+     * npx convex run auth:rotateKeys | npx convex env set JWKS
+     * ```
+     * Then use it in your auth config and Better Auth options:
+     *
+     * ```ts
+     * // convex/auth.config.ts
+     * export default {
+     *   providers: [getAuthConfigProvider({ jwks: process.env.JWKS })],
+     * } satisfies AuthConfig;
+     *
+     * // convex/auth.ts
+     * export const createAuth = (ctx: GenericCtx<DataModel>) => {
+     *   return betterAuth({
+     *     // ...
+     *     plugins: [convex({ authConfig, jwks: process.env.JWKS })],
+     *   });
+     * };
+     * ```
+     */
+    jwks?: string;
+    /**
+     * @param {boolean} jwksRotateOnTokenGenerationError - Whether to rotate the JWKS on token generation error.
+     *
+     * Does nothing if a static JWKS is provided.
+     *
+     * Handles error that occurs when existing JWKS key does not match configured
+     * algorithm, which will be common for 0.10 upgrades switching from EdDSA to RS256.
+     *
+     * @default true
+     */
+    jwksRotateOnTokenGenerationError?: boolean;
+    /**
+     * @param {BetterAuthOptions} options - Better Auth options. Not required,
+     * currently used to pass the basePath to the oidcProvider plugin.
+     */
+    options?: BetterAuthOptions;
 }) => {
     id: "convex";
-    init: ({ logger, options }: import("better-auth").AuthContext) => void;
+    init: (ctx: import("better-auth").AuthContext<BetterAuthOptions>) => void;
     hooks: {
         before: ({
-            matcher(context: import("better-call").EndpointContext<string, any> & Omit<import("better-call").InputContext<string, any>, "method"> & {
-                context: import("better-auth").AuthContext & {
-                    returned?: unknown;
-                    responseHeaders?: Headers;
-                };
-                headers?: Headers;
-            }): boolean;
+            matcher(context: import("better-auth").HookEndpointContext): boolean;
             handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
                 context: {
                     headers: Headers;
                 };
             } | undefined>;
         } | {
-            matcher: (ctx: import("better-call").EndpointContext<string, any> & Omit<import("better-call").InputContext<string, any>, "method"> & {
-                context: import("better-auth").AuthContext & {
-                    returned?: unknown;
-                    responseHeaders?: Headers;
-                };
-                headers?: Headers;
-            }) => boolean;
+            matcher: (ctx: import("better-auth").HookEndpointContext) => boolean;
             handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
-                context: import("better-call").MiddlewareContext<import("better-call").MiddlewareOptions, import("better-auth").AuthContext<import("better-auth").BetterAuthOptions> & {
-                    returned?: unknown;
-                    responseHeaders?: Headers;
+                context: import("better-call").MiddlewareContext<import("better-call").MiddlewareOptions, import("better-auth").AuthContext<BetterAuthOptions> & {
+                    returned?: unknown | undefined;
+                    responseHeaders?: Headers | undefined;
                 }>;
             }>;
         })[];
@@ -44,226 +127,152 @@ export declare const convex: (opts?: {
                 url: string;
             } | undefined>;
         } | {
-            matcher: (ctx: import("better-call").EndpointContext<string, any> & Omit<import("better-call").InputContext<string, any>, "method"> & {
-                context: import("better-auth").AuthContext & {
-                    returned?: unknown;
-                    responseHeaders?: Headers;
-                };
-                headers?: Headers;
-            }) => boolean;
+            matcher: (ctx: import("better-auth").HookEndpointContext) => boolean;
             handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
         })[];
     };
     endpoints: {
-        getOpenIdConfig: {
-            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
-                body?: undefined;
-            } & {
-                method?: "GET" | undefined;
-            } & {
-                query?: Record<string, any> | undefined;
-            } & {
-                params?: Record<string, any>;
-            } & {
-                request?: Request;
-            } & {
-                headers?: HeadersInit;
-            } & {
-                asResponse?: boolean;
-                returnHeaders?: boolean;
-                use?: import("better-call").Middleware[];
-                path?: string;
-            } & {
-                asResponse?: AsResponse | undefined;
-                returnHeaders?: ReturnHeaders | undefined;
-            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
-                headers: Headers;
-                response: import("better-auth/plugins").OIDCMetadata;
-            } : import("better-auth/plugins").OIDCMetadata>;
-            options: {
-                method: "GET";
-                metadata: {
-                    isAction: boolean;
-                };
-            } & {
-                use: any[];
+        getOpenIdConfig: import("better-call").StrictEndpoint<"/convex/.well-known/openid-configuration", {
+            method: "GET";
+            metadata: {
+                isAction: false;
             };
-            path: "/convex/.well-known/openid-configuration";
-        };
-        getJwks: {
-            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
-                body?: undefined;
-            } & {
-                method?: "GET" | undefined;
-            } & {
-                query?: Record<string, any> | undefined;
-            } & {
-                params?: Record<string, any>;
-            } & {
-                request?: Request;
-            } & {
-                headers?: HeadersInit;
-            } & {
-                asResponse?: boolean;
-                returnHeaders?: boolean;
-                use?: import("better-call").Middleware[];
-                path?: string;
-            } & {
-                asResponse?: AsResponse | undefined;
-                returnHeaders?: ReturnHeaders | undefined;
-            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
-                headers: Headers;
-                response: import("jose").JSONWebKeySet;
-            } : import("jose").JSONWebKeySet>;
-            options: {
-                method: "GET";
-                metadata: {
-                    openapi: {
-                        description: string;
-                        responses: {
-                            "200": {
-                                description: string;
-                                content: {
-                                    "application/json": {
-                                        schema: {
-                                            type: "object";
-                                            properties: {
-                                                keys: {
+        }, import("better-auth/plugins").OIDCMetadata>;
+        getJwks: import("better-call").StrictEndpoint<"/convex/jwks", {
+            method: "GET";
+            metadata: {
+                openapi: {
+                    description: string;
+                    responses: {
+                        "200": {
+                            description: string;
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object";
+                                        properties: {
+                                            keys: {
+                                                type: string;
+                                                description: string;
+                                                items: {
                                                     type: string;
-                                                    description: string;
-                                                    items: {
-                                                        type: string;
-                                                        properties: {
-                                                            kid: {
-                                                                type: string;
-                                                                description: string;
-                                                            };
-                                                            kty: {
-                                                                type: string;
-                                                                description: string;
-                                                            };
-                                                            alg: {
-                                                                type: string;
-                                                                description: string;
-                                                            };
-                                                            use: {
-                                                                type: string;
-                                                                description: string;
-                                                                enum: string[];
-                                                                nullable: boolean;
-                                                            };
-                                                            n: {
-                                                                type: string;
-                                                                description: string;
-                                                                nullable: boolean;
-                                                            };
-                                                            e: {
-                                                                type: string;
-                                                                description: string;
-                                                                nullable: boolean;
-                                                            };
-                                                            crv: {
-                                                                type: string;
-                                                                description: string;
-                                                                nullable: boolean;
-                                                            };
-                                                            x: {
-                                                                type: string;
-                                                                description: string;
-                                                                nullable: boolean;
-                                                            };
-                                                            y: {
-                                                                type: string;
-                                                                description: string;
-                                                                nullable: boolean;
-                                                            };
+                                                    properties: {
+                                                        kid: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        kty: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        alg: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        use: {
+                                                            type: string;
+                                                            description: string;
+                                                            enum: string[];
+                                                            nullable: boolean;
+                                                        };
+                                                        n: {
+                                                            type: string;
+                                                            description: string;
+                                                            nullable: boolean;
+                                                        };
+                                                        e: {
+                                                            type: string;
+                                                            description: string;
+                                                            nullable: boolean;
+                                                        };
+                                                        crv: {
+                                                            type: string;
+                                                            description: string;
+                                                            nullable: boolean;
+                                                        };
+                                                        x: {
+                                                            type: string;
+                                                            description: string;
+                                                            nullable: boolean;
+                                                        };
+                                                        y: {
+                                                            type: string;
+                                                            description: string;
+                                                            nullable: boolean;
                                                         };
-                                                        required: string[];
                                                     };
+                                                    required: string[];
                                                 };
                                             };
-                                            required: string[];
                                         };
+                                        required: string[];
                                     };
                                 };
                             };
                         };
                     };
                 };
-            } & {
-                use: any[];
             };
-            path: "/convex/jwks";
-        };
-        getToken: {
-            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
-                body?: undefined;
-            } & {
-                method?: "GET" | undefined;
-            } & {
-                query?: Record<string, any> | undefined;
-            } & {
-                params?: Record<string, any>;
-            } & {
-                request?: Request;
-            } & {
-                headers: HeadersInit;
-            } & {
-                asResponse?: boolean;
-                returnHeaders?: boolean;
-                use?: import("better-call").Middleware[];
-                path?: string;
-            } & {
-                asResponse?: AsResponse | undefined;
-                returnHeaders?: ReturnHeaders | undefined;
-            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
-                headers: Headers;
-                response: {
-                    token: string;
+        }, import("jose").JSONWebKeySet>;
+        getLatestJwks: import("better-call").StrictEndpoint<string, {
+            isAction: boolean;
+            method: "POST";
+            metadata: {
+                SERVER_ONLY: true;
+                openapi: {
+                    description: string;
                 };
-            } : {
-                token: string;
-            }>;
-            options: {
-                method: "GET";
-                requireHeaders: true;
-                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
-                    session: {
-                        session: Record<string, any> & {
-                            id: string;
-                            createdAt: Date;
-                            updatedAt: Date;
-                            userId: string;
-                            expiresAt: Date;
-                            token: string;
-                            ipAddress?: string | null | undefined;
-                            userAgent?: string | null | undefined;
-                        };
-                        user: Record<string, any> & {
-                            id: string;
-                            createdAt: Date;
-                            updatedAt: Date;
-                            email: string;
-                            emailVerified: boolean;
-                            name: string;
-                            image?: string | null | undefined;
-                        };
+            };
+        }, any[]>;
+        rotateKeys: import("better-call").StrictEndpoint<string, {
+            isAction: boolean;
+            method: "POST";
+            metadata: {
+                SERVER_ONLY: true;
+                openapi: {
+                    description: string;
+                };
+            };
+        }, any[]>;
+        getToken: import("better-call").StrictEndpoint<"/convex/token", {
+            method: "GET";
+            requireHeaders: true;
+            use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                session: {
+                    session: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        userId: string;
+                        expiresAt: Date;
+                        token: string;
+                        ipAddress?: string | null | undefined;
+                        userAgent?: string | null | undefined;
                     };
-                }>)[];
-                metadata: {
-                    openapi: {
-                        description: string;
-                        responses: {
-                            200: {
-                                description: string;
-                                content: {
-                                    "application/json": {
-                                        schema: {
-                                            type: "object";
-                                            properties: {
-                                                token: {
-                                                    type: string;
-                                                };
+                    user: Record<string, any> & {
+                        id: string;
+                        createdAt: Date;
+                        updatedAt: Date;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image?: string | null | undefined;
+                    };
+                };
+            }>)[];
+            metadata: {
+                openapi: {
+                    description: string;
+                    responses: {
+                        200: {
+                            description: string;
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object";
+                                        properties: {
+                                            token: {
+                                                type: string;
                                             };
                                         };
                                     };
@@ -272,11 +281,10 @@ export declare const convex: (opts?: {
                         };
                     };
                 };
-            } & {
-                use: any[];
             };
-            path: "/convex/token";
-        };
+        }, {
+            token: string;
+        }>;
     };
     schema: {
         jwks: {
@@ -293,6 +301,10 @@ export declare const convex: (opts?: {
                     type: "date";
                     required: true;
                 };
+                expiresAt: {
+                    type: "date";
+                    required: false;
+                };
             };
         };
         user: {

package/dist/plugins/convex/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/convex/index.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,eAAe,eAAe,CAAC;AAE5C,eAAO,MAAM,MAAM,GACjB,OAAM;IACJ,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5B;;;;;;;4BAM6B,CAAC;mCACF,CAAC;;uBAAqD,CAAC;;;;;;;;;;4BAkBtF,CAAC;mCAAkC,CAAC;;;;;;;;;;;;;;;;;;;;4BAApC,CAAC;mCAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCA4Q46Y,CAAC;qCAAkD,CAAC;;;;;;;;;iCAA0Q,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CADnxZ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/convex/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,OAAO,EACZ,KAAK,IAAI,EACV,MAAM,aAAa,CAAC;AAWrB,OAAO,KAAK,EAAE,UAAU,EAAgB,MAAM,eAAe,CAAC;AAE9D,eAAO,MAAM,eAAe,eAAe,CAAC;AA6C5C,eAAO,MAAM,MAAM,GAAI,MAAM;IAC3B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,UAAU,EAAE,UAAU,CAAC;IACvB;;;;OAIG;IACH,GAAG,CAAC,EAAE;QACJ,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE;YACxB,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;YACjC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;SACxC,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;KACtE,CAAC;IACF;;OAEG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;;;;;OASG;IACH,gCAAgC,CAAC,EAAE,OAAO,CAAC;IAC3C;;;OAGG;IACH,OAAO,CAAC,EAAE,iBAAiB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA1FE,CADG;iCACc,CAAC;;;;;;;;;6BASb,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAigBR,CAAC"}