@convex-dev/better-auth 0.6.0

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

@@ -0,0 +1,280 @@
+import { getSession } from "better-auth/api";
+export declare const convex: (opts?: {
+    jwtExpirationSeconds?: number;
+}) => {
+    id: "convex";
+    hooks: {
+        before: {
+            matcher(context: import("better-auth").HookEndpointContext): boolean;
+            handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                context: {
+                    headers: Headers;
+                };
+            } | undefined>;
+        }[];
+        after: ({
+            matcher(): true;
+            handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<Response | undefined>;
+        } | {
+            matcher: (ctx: import("better-auth").HookEndpointContext) => boolean;
+            handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
+        })[];
+    };
+    endpoints: {
+        getSession: ReturnType<typeof getSession>;
+        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[];
+            };
+            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: {
+                    keys: any[];
+                };
+            } : {
+                keys: any[];
+            }>;
+            options: {
+                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;
+                                                        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[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                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;
+                };
+            } : {
+                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;
+                            name: string;
+                            email: string;
+                            emailVerified: boolean;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                token: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                use: any[];
+            };
+            path: "/convex/token";
+        };
+    };
+    schema: {
+        jwks: {
+            fields: {
+                publicKey: {
+                    type: "string";
+                    required: true;
+                };
+                privateKey: {
+                    type: "string";
+                    required: true;
+                };
+                createdAt: {
+                    type: "date";
+                    required: true;
+                };
+            };
+        };
+        user: {
+            readonly fields: {
+                readonly userId: {
+                    readonly type: "string";
+                    readonly required: false;
+                    readonly input: false;
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/convex/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,UAAU,EAEX,MAAM,iBAAiB,CAAC;AAczB,eAAO,MAAM,MAAM,GAAI,OAAM;IAAE,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAAO;;;;;;;;;;;;;;;;;;;;oBAyH7C,UAAU,CAAC,OAAO,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCA6Js3kF,CAAC;qCAAkD,CAAC;;;;;;;;;iCAA0Q,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CADvulF,CAAC"}

package/dist/esm/plugins/convex/index.js

@@ -0,0 +1,253 @@
+import { createAuthMiddleware, sessionMiddleware, } from "better-auth/api";
+import { createAuthEndpoint, customSession as customSessionPlugin, jwt as jwtPlugin, bearer as bearerPlugin, oidcProvider as oidcProviderPlugin, } from "better-auth/plugins";
+import { omit } from "convex-helpers";
+import { z } from "zod";
+const JWT_COOKIE_NAME = "convex_jwt";
+export const convex = (opts = {}) => {
+    const { jwtExpirationSeconds = 60 * 15 } = opts;
+    const customSession = customSessionPlugin(async ({ user, session }) => {
+        const { userId, ...userData } = omit(user, ["id"]);
+        return {
+            user: { ...userData, id: userId },
+            session: {
+                ...session,
+                userId,
+            },
+        };
+    });
+    const oidcProvider = oidcProviderPlugin({
+        loginPage: "/not-used",
+        metadata: {
+            issuer: `${process.env.CONVEX_SITE_URL}`,
+            jwks_uri: `${process.env.CONVEX_SITE_URL}/api/auth/convex/jwks`,
+        },
+    });
+    const jwt = jwtPlugin({
+        jwt: {
+            issuer: `${process.env.CONVEX_SITE_URL}`,
+            audience: "convex",
+            expirationTime: `${jwtExpirationSeconds}s`,
+            getSubject: (session) => {
+                // Return the userId from the app user table
+                return session.user.userId;
+            },
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            definePayload: ({ user: { id, userId, ...user }, session }) => ({
+                ...user,
+                sessionId: session.id,
+            }),
+        },
+    });
+    // Bearer plugin converts the session token to a cookie
+    // for cross domain social login after code verification, and is required for
+    // the headers() helper to work.
+    const bearer = bearerPlugin();
+    const schema = {
+        user: {
+            fields: { userId: { type: "string", required: false, input: false } },
+        },
+        ...jwt.schema,
+    };
+    return {
+        id: "convex",
+        hooks: {
+            before: [...bearer.hooks.before],
+            after: [
+                ...oidcProvider.hooks.after,
+                {
+                    matcher: (ctx) => {
+                        return ctx.path?.startsWith("/sign-out");
+                    },
+                    handler: createAuthMiddleware(async (ctx) => {
+                        const jwtCookie = ctx.context.createAuthCookie(JWT_COOKIE_NAME, {
+                            maxAge: 0,
+                        });
+                        ctx.setCookie(jwtCookie.name, "", jwtCookie.attributes);
+                    }),
+                },
+            ],
+        },
+        endpoints: {
+            getSession: createAuthEndpoint("/get-session", {
+                method: "GET",
+                query: z.optional(z.object({
+                    // If cookie cache is enabled, it will disable the cache
+                    // and fetch the session from the database
+                    disableCookieCache: z
+                        .boolean({
+                        description: "Disable cookie cache and fetch session from database",
+                    })
+                        .or(z.string().transform((v) => v === "true"))
+                        .optional(),
+                    disableRefresh: z
+                        .boolean({
+                        description: "Disable session refresh. Useful for checking session status, without updating the session",
+                    })
+                        .optional(),
+                })),
+                metadata: {
+                    CUSTOM_SESSION: true,
+                    openapi: {
+                        description: "Get custom session data",
+                        responses: {
+                            "200": {
+                                description: "Success",
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "array",
+                                            nullable: true,
+                                            items: {
+                                                $ref: "#/components/schemas/Session",
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                requireHeaders: true,
+            }, async (ctx) => {
+                const response = await customSession.endpoints.getSession({
+                    ...ctx,
+                    returnHeaders: false,
+                });
+                return response;
+            }),
+            getOpenIdConfig: createAuthEndpoint("/convex/.well-known/openid-configuration", {
+                method: "GET",
+                metadata: {
+                    isAction: false,
+                },
+            }, async (ctx) => {
+                const response = await oidcProvider.endpoints.getOpenIdConfig({
+                    ...ctx,
+                    returnHeaders: false,
+                });
+                return response;
+            }),
+            getJwks: createAuthEndpoint("/convex/jwks", {
+                method: "GET",
+                metadata: {
+                    openapi: {
+                        description: "Get the JSON Web Key Set",
+                        responses: {
+                            "200": {
+                                description: "JSON Web Key Set retrieved successfully",
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object",
+                                            properties: {
+                                                keys: {
+                                                    type: "array",
+                                                    description: "Array of public JSON Web Keys",
+                                                    items: {
+                                                        type: "object",
+                                                        properties: {
+                                                            kid: {
+                                                                type: "string",
+                                                                description: "Key ID uniquely identifying the key, corresponds to the 'id' from the stored Jwk",
+                                                            },
+                                                            kty: {
+                                                                type: "string",
+                                                                description: "Key type (e.g., 'RSA', 'EC', 'OKP')",
+                                                            },
+                                                            alg: {
+                                                                type: "string",
+                                                                description: "Algorithm intended for use with the key (e.g., 'EdDSA', 'RS256')",
+                                                            },
+                                                            use: {
+                                                                type: "string",
+                                                                description: "Intended use of the public key (e.g., 'sig' for signature)",
+                                                                enum: ["sig"],
+                                                                nullable: true,
+                                                            },
+                                                            n: {
+                                                                type: "string",
+                                                                description: "Modulus for RSA keys (base64url-encoded)",
+                                                                nullable: true,
+                                                            },
+                                                            e: {
+                                                                type: "string",
+                                                                description: "Exponent for RSA keys (base64url-encoded)",
+                                                                nullable: true,
+                                                            },
+                                                            crv: {
+                                                                type: "string",
+                                                                description: "Curve name for elliptic curve keys (e.g., 'Ed25519', 'P-256')",
+                                                                nullable: true,
+                                                            },
+                                                            x: {
+                                                                type: "string",
+                                                                description: "X coordinate for elliptic curve keys (base64url-encoded)",
+                                                                nullable: true,
+                                                            },
+                                                            y: {
+                                                                type: "string",
+                                                                description: "Y coordinate for elliptic curve keys (base64url-encoded)",
+                                                                nullable: true,
+                                                            },
+                                                        },
+                                                        required: ["kid", "kty", "alg"],
+                                                    },
+                                                },
+                                            },
+                                            required: ["keys"],
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            }, async (ctx) => {
+                const response = await jwt.endpoints.getJwks({
+                    ...ctx,
+                    returnHeaders: false,
+                });
+                return response;
+            }),
+            getToken: createAuthEndpoint("/convex/token", {
+                method: "GET",
+                requireHeaders: true,
+                use: [sessionMiddleware],
+                metadata: {
+                    openapi: {
+                        description: "Get a JWT token",
+                        responses: {
+                            200: {
+                                description: "Success",
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object",
+                                            properties: {
+                                                token: {
+                                                    type: "string",
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            }, async (ctx) => {
+                const response = await jwt.endpoints.getToken({
+                    ...ctx,
+                    returnHeaders: false,
+                });
+                const jwtCookie = ctx.context.createAuthCookie(JWT_COOKIE_NAME, {
+                    maxAge: jwtExpirationSeconds,
+                });
+                ctx.setCookie(jwtCookie.name, response.token, jwtCookie.attributes);
+                return response;
+            }),
+        },
+        schema,
+    };
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/plugins/convex/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/plugins/convex/index.ts"],"names":[],"mappings":"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"}

package/dist/esm/plugins/cross-domain/client.d.ts

@@ -0,0 +1,123 @@
+import type { Store } from "better-auth";
+import { BetterFetchOption } from "@better-fetch/fetch";
+import { crossDomain } from "./index.js";
+interface CookieAttributes {
+    value: string;
+    expires?: Date;
+    "max-age"?: number;
+    domain?: string;
+    path?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: "Strict" | "Lax" | "None";
+}
+export declare function parseSetCookieHeader(header: string): Map<string, CookieAttributes>;
+export declare function getSetCookie(header: string, prevCookie?: string): string;
+export declare function getCookie(cookie: string): string;
+export declare const crossDomainClient: (opts?: {
+    storage?: {
+        setItem: (key: string, value: string) => any;
+        getItem: (key: string) => string | null;
+    };
+    storagePrefix?: string;
+    disableCache?: boolean;
+}) => {
+    id: "cross-domain";
+    $InferServerPlugin: ReturnType<typeof crossDomain>;
+    getActions(_: import("@better-fetch/fetch").BetterFetch, $store: Store): {
+        /**
+         * Get the stored cookie.
+         *
+         * You can use this to get the cookie stored in the device and use it in your fetch
+         * requests.
+         *
+         * @example
+         * ```ts
+         * const cookie = client.getCookie();
+         * fetch("https://api.example.com", {
+         * 	headers: {
+         * 		cookie,
+         * 	},
+         * });
+         */
+        getCookie: () => string;
+        /**
+         * Notify the session signal.
+         *
+         * This is used to trigger an update in useSession, generally when a new session
+         * token is set.
+         *
+         * @example
+         * ```ts
+         * client.notifySessionSignal();
+         * ```
+         */
+        updateSession: () => void;
+    };
+    fetchPlugins: {
+        id: string;
+        name: string;
+        hooks: {
+            onSuccess(context: import("@better-fetch/fetch").SuccessContext<any>): Promise<void>;
+        };
+        init(url: string, options: {
+            headers?: (HeadersInit & (HeadersInit | {
+                accept: "application/json" | "text/plain" | "application/octet-stream";
+                "content-type": "application/json" | "text/plain" | "application/x-www-form-urlencoded" | "multipart/form-data" | "application/octet-stream";
+                authorization: "Bearer" | "Basic";
+            })) | undefined;
+            method?: string | undefined;
+            cache?: RequestCache | undefined;
+            credentials?: RequestCredentials | undefined;
+            integrity?: string | undefined;
+            keepalive?: boolean | undefined;
+            mode?: RequestMode | undefined;
+            priority?: RequestPriority | undefined;
+            redirect?: RequestRedirect | undefined;
+            referrer?: string | undefined;
+            referrerPolicy?: ReferrerPolicy | undefined;
+            signal?: (AbortSignal | null) | undefined;
+            window?: null | undefined;
+            onRequest?: (<T extends Record<string, any>>(context: import("@better-fetch/fetch").RequestContext<T>) => Promise<import("@better-fetch/fetch").RequestContext | void> | import("@better-fetch/fetch").RequestContext | void) | undefined;
+            onResponse?: ((context: import("@better-fetch/fetch").ResponseContext) => Promise<Response | void | import("@better-fetch/fetch").ResponseContext> | Response | import("@better-fetch/fetch").ResponseContext | void) | undefined;
+            onSuccess?: ((context: import("@better-fetch/fetch").SuccessContext<any>) => Promise<void> | void) | undefined;
+            onError?: ((context: import("@better-fetch/fetch").ErrorContext) => Promise<void> | void) | undefined;
+            onRetry?: ((response: import("@better-fetch/fetch").ResponseContext) => Promise<void> | void) | undefined;
+            hookOptions?: {
+                cloneResponse?: boolean;
+            } | undefined;
+            timeout?: number | undefined;
+            customFetchImpl?: import("@better-fetch/fetch").FetchEsque | undefined;
+            plugins?: import("@better-fetch/fetch").BetterFetchPlugin[] | undefined;
+            baseURL?: string | undefined;
+            throw?: boolean | undefined;
+            auth?: ({
+                type: "Bearer";
+                token: string | Promise<string | undefined> | (() => string | Promise<string | undefined> | undefined) | undefined;
+            } | {
+                type: "Basic";
+                username: string | (() => string | undefined) | undefined;
+                password: string | (() => string | undefined) | undefined;
+            } | {
+                type: "Custom";
+                prefix: string | (() => string | undefined) | undefined;
+                value: string | (() => string | undefined) | undefined;
+            }) | undefined;
+            body?: any;
+            query?: any;
+            params?: any;
+            duplex?: "full" | "half" | undefined;
+            jsonParser?: ((text: string) => Promise<any> | any) | undefined;
+            retry?: import("@better-fetch/fetch").RetryOptions | undefined;
+            retryAttempt?: number | undefined;
+            output?: (import("@better-fetch/fetch").StandardSchemaV1 | typeof Blob | typeof File) | undefined;
+            errorSchema?: import("@better-fetch/fetch").StandardSchemaV1 | undefined;
+            disableValidation?: boolean | undefined;
+        } | undefined): Promise<{
+            url: string;
+            options: BetterFetchOption;
+        }>;
+    }[];
+};
+export {};
+//# sourceMappingURL=client.d.ts.map