payload-auth 1.0.2 → 1.1.1

package/dist/better-auth/plugin/lib/build-collections/two-factors.js

@@ -0,0 +1,56 @@
+import { betterAuthPluginSlugs, baseCollectionSlugs } from "../constants";
+import { getTimestampFields } from "./utils/get-timestamp-fields";
+import { getAdminAccess } from "../../helpers/get-admin-access";
+export function buildTwoFactorsCollection({ pluginOptions }) {
+    const twoFactorSlug = betterAuthPluginSlugs.twoFactors;
+    const userSlug = pluginOptions.users?.slug ?? baseCollectionSlugs.users;
+    const twoFactorCollection = {
+        slug: twoFactorSlug,
+        admin: {
+            hidden: pluginOptions.hidePluginCollections ?? false,
+            useAsTitle: "secret",
+            description: "Two factor authentication secrets",
+            group: pluginOptions?.collectionAdminGroup ?? "Auth"
+        },
+        access: {
+            ...getAdminAccess(pluginOptions)
+        },
+        fields: [
+            {
+                name: "user",
+                type: "relationship",
+                relationTo: userSlug,
+                required: true,
+                label: "User",
+                admin: {
+                    readOnly: true,
+                    description: "The user that the two factor authentication secret belongs to"
+                }
+            },
+            {
+                name: "secret",
+                type: "text",
+                label: "Secret",
+                index: true,
+                admin: {
+                    readOnly: true,
+                    description: "The secret used to generate the TOTP code."
+                }
+            },
+            {
+                name: "backupCodes",
+                type: "text",
+                required: true,
+                label: "Backup Codes",
+                admin: {
+                    readOnly: true,
+                    description: "The backup codes used to recover access to the account if the user loses access to their phone or email"
+                }
+            },
+            ...getTimestampFields()
+        ]
+    };
+    return twoFactorCollection;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/lib/build-collections/users/better-auth-strategy.d.ts

@@ -0,0 +1,8 @@
+import type { AuthStrategy } from "payload";
+/**
+ * Auth strategy for BetterAuth
+ * @param userSlug - User collection slug
+ * @returns Auth strategy
+ */
+export declare function betterAuthStrategy(userSlug?: string): AuthStrategy;
+//# sourceMappingURL=better-auth-strategy.d.ts.map

package/dist/better-auth/plugin/lib/build-collections/users/better-auth-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"better-auth-strategy.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/lib/build-collections/users/better-auth-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAG5C;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,YAAY,CAyClE"}

package/dist/better-auth/plugin/lib/build-collections/users/better-auth-strategy.js

@@ -0,0 +1,52 @@
+import { getPayloadAuth } from "../../../lib/get-payload-auth";
+/**
+ * Auth strategy for BetterAuth
+ * @param userSlug - User collection slug
+ * @returns Auth strategy
+ */ export function betterAuthStrategy(userSlug) {
+    return {
+        name: "better-auth",
+        authenticate: async ({ payload, headers })=>{
+            try {
+                const payloadAuth = await getPayloadAuth(payload.config);
+                const res = await payloadAuth.betterAuth.api.getSession({
+                    headers
+                });
+                if (!res) {
+                    return {
+                        user: null
+                    };
+                }
+                const userId = res.user.id ?? res.session.userId ?? ("user" in res.session && typeof res.session.user === "string" ? res.session.user : null);
+                if (!userId) {
+                    return {
+                        user: null
+                    };
+                }
+                const user = await payloadAuth.findByID({
+                    collection: userSlug ?? "users",
+                    id: userId
+                });
+                if (!user) {
+                    return {
+                        user: null
+                    };
+                }
+                return {
+                    user: {
+                        ...user,
+                        collection: userSlug ?? "users",
+                        _strategy: "better-auth"
+                    }
+                };
+            } catch (error) {
+                console.error(error);
+                return {
+                    user: null
+                };
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/lib/build-collections/users/endpoints/forgot-password.d.ts

@@ -0,0 +1,3 @@
+import { Endpoint } from "payload";
+export declare const getForgotPasswordEndpoint: () => Endpoint;
+//# sourceMappingURL=forgot-password.d.ts.map

package/dist/better-auth/plugin/lib/build-collections/users/endpoints/forgot-password.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forgot-password.d.ts","sourceRoot":"","sources":["../../../../../../../src/better-auth/plugin/lib/build-collections/users/endpoints/forgot-password.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,QAAQ,EAKT,MAAM,SAAS,CAAC;AAkBjB,eAAO,MAAM,yBAAyB,QAAO,QA2F5C,CAAC"}

package/dist/better-auth/plugin/lib/build-collections/users/endpoints/forgot-password.js

@@ -0,0 +1,96 @@
+import { addDataAndFileToRequest, APIError, commitTransaction, headersWithCors, initTransaction, killTransaction } from "payload";
+import { status as httpStatus } from "http-status";
+import { getPayloadAuth } from "../../../get-payload-auth";
+import { z } from "zod";
+import { getRequestCollection } from "../../../../helpers/get-requst-collection";
+import { getLoginOptions } from "payload/shared";
+import { getAdminRoutes } from "../../../../helpers/get-admin-routes";
+const requestSchema = z.object({
+    email: z.string().email().optional(),
+    username: z.string().optional()
+});
+export const getForgotPasswordEndpoint = ()=>{
+    const endpoint = {
+        path: "/forgot-password",
+        method: "post",
+        handler: async (req)=>{
+            await addDataAndFileToRequest(req);
+            const { t } = req;
+            const body = requestSchema.safeParse(req.data);
+            if (!body.success) {
+                return Response.json({
+                    message: body.error.message
+                }, {
+                    status: httpStatus.BAD_REQUEST
+                });
+            }
+            const adminRoutes = getAdminRoutes(req.payload.config.admin.custom);
+            const redirectUrl = `${req.payload.config.routes?.admin || "/admin"}${adminRoutes.resetPassword}`;
+            const { email, username } = body.data;
+            const collection = getRequestCollection(req);
+            const loginWithUsername = collection.config.auth?.loginWithUsername;
+            const { canLoginWithEmail, canLoginWithUsername } = getLoginOptions(loginWithUsername);
+            const sanitizedEmail = canLoginWithEmail && (email || "").toLowerCase().trim() || null;
+            const sanitizedUsername = username?.toLowerCase().trim() || null;
+            if (!sanitizedEmail && !sanitizedUsername) {
+                throw new APIError(`Missing ${loginWithUsername ? "username" : "email"}.`, httpStatus.BAD_REQUEST);
+            }
+            try {
+                await initTransaction(req);
+                let whereConstraint = {};
+                if (canLoginWithEmail && sanitizedEmail) {
+                    whereConstraint = {
+                        email: {
+                            equals: sanitizedEmail
+                        }
+                    };
+                } else if (canLoginWithUsername && sanitizedUsername) {
+                    whereConstraint = {
+                        username: {
+                            equals: sanitizedUsername
+                        }
+                    };
+                }
+                const res = await req.payload.find({
+                    collection: collection.config.slug,
+                    req,
+                    where: whereConstraint
+                });
+                // We don't want to indicate specifically that an email was not found,
+                // as doing so could lead to the exposure of registered emails.
+                // Therefore, we prefer to fail silently.
+                if (res.docs.length === 0) {
+                    await commitTransaction(req);
+                    return Response.json({
+                        message: t("general:success")
+                    }, {
+                        status: httpStatus.OK
+                    });
+                }
+                const user = res.docs[0];
+                const payloadAuth = await getPayloadAuth(req.payload.config);
+                await payloadAuth.betterAuth.api.forgetPassword({
+                    body: {
+                        email: user.email,
+                        redirectTo: redirectUrl
+                    }
+                });
+                return Response.json({
+                    message: t("general:success")
+                }, {
+                    headers: headersWithCors({
+                        headers: new Headers(),
+                        req
+                    }),
+                    status: httpStatus.OK
+                });
+            } catch (error) {
+                await killTransaction(req);
+                throw error;
+            }
+        }
+    };
+    return endpoint;
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../../src/better-auth/plugin/lib/build-collections/users/endpoints/forgot-password.ts"],"sourcesContent":["import {\n  addDataAndFileToRequest,\n  APIError,\n  commitTransaction,\n  Endpoint,\n  headersWithCors,\n  initTransaction,\n  killTransaction,\n  Where,\n} from \"payload\";\nimport {\n  BetterAuthPluginOptions,\n  ConfigAdminCustom,\n  SanitizedBetterAuthOptions,\n} from \"../../../../types\";\nimport { status as httpStatus } from \"http-status\";\nimport { getPayloadAuth } from \"../../../get-payload-auth\";\nimport { z } from \"zod\";\nimport { getRequestCollection } from \"../../../../helpers/get-requst-collection\";\nimport { getLoginOptions } from \"payload/shared\";\nimport { getAdminRoutes } from \"../../../../helpers/get-admin-routes\";\n\nconst requestSchema = z.object({\n  email: z.string().email().optional(),\n  username: z.string().optional(),\n});\n\nexport const getForgotPasswordEndpoint = (): Endpoint => {\n  const endpoint: Endpoint = {\n    path: \"/forgot-password\",\n    method: \"post\",\n    handler: async (req) => {\n      await addDataAndFileToRequest(req);\n      const { t } = req;\n      const body = requestSchema.safeParse(req.data);\n      if (!body.success) {\n        return Response.json(\n          { message: body.error.message },\n          { status: httpStatus.BAD_REQUEST }\n        );\n      }\n      const adminRoutes = getAdminRoutes(req.payload.config.admin.custom);\n      const redirectUrl = `${req.payload.config.routes?.admin || \"/admin\"}${adminRoutes.resetPassword}`;\n      const { email, username } = body.data;\n      const collection = getRequestCollection(req);\n      const loginWithUsername = collection.config.auth?.loginWithUsername;\n      const { canLoginWithEmail, canLoginWithUsername } =\n        getLoginOptions(loginWithUsername);\n      const sanitizedEmail =\n        (canLoginWithEmail && (email || \"\").toLowerCase().trim()) || null;\n      const sanitizedUsername = username?.toLowerCase().trim() || null;\n      if (!sanitizedEmail && !sanitizedUsername) {\n        throw new APIError(\n          `Missing ${loginWithUsername ? \"username\" : \"email\"}.`,\n          httpStatus.BAD_REQUEST\n        );\n      }\n\n      try {\n        await initTransaction(req);\n        let whereConstraint: Where = {};\n        if (canLoginWithEmail && sanitizedEmail) {\n          whereConstraint = {\n            email: {\n              equals: sanitizedEmail,\n            },\n          };\n        } else if (canLoginWithUsername && sanitizedUsername) {\n          whereConstraint = {\n            username: {\n              equals: sanitizedUsername,\n            },\n          };\n        }\n        const res = await req.payload.find({\n          collection: collection.config.slug,\n          req,\n          where: whereConstraint,\n        });\n        // We don't want to indicate specifically that an email was not found,\n        // as doing so could lead to the exposure of registered emails.\n        // Therefore, we prefer to fail silently.\n        if (res.docs.length === 0) {\n          await commitTransaction(req);\n          return Response.json(\n            {\n              message: t(\"general:success\"),\n            },\n            { status: httpStatus.OK }\n          );\n        }\n        const user = res.docs[0];\n        const payloadAuth = await getPayloadAuth(req.payload.config);\n        await payloadAuth.betterAuth.api.forgetPassword({\n          body: {\n            email: user.email,\n            redirectTo: redirectUrl,\n          },\n        });\n        return Response.json(\n          {\n            message: t(\"general:success\"),\n          },\n          {\n            headers: headersWithCors({\n              headers: new Headers(),\n              req,\n            }),\n            status: httpStatus.OK,\n          }\n        );\n      } catch (error) {\n        await killTransaction(req);\n        throw error;\n      }\n    },\n  };\n  return endpoint;\n};\n"],"names":["addDataAndFileToRequest","APIError","commitTransaction","headersWithCors","initTransaction","killTransaction","status","httpStatus","getPayloadAuth","z","getRequestCollection","getLoginOptions","getAdminRoutes","requestSchema","object","email","string","optional","username","getForgotPasswordEndpoint","endpoint","path","method","handler","req","t","body","safeParse","data","success","Response","json","message","error","BAD_REQUEST","adminRoutes","payload","config","admin","custom","redirectUrl","routes","resetPassword","collection","loginWithUsername","auth","canLoginWithEmail","canLoginWithUsername","sanitizedEmail","toLowerCase","trim","sanitizedUsername","whereConstraint","equals","res","find","slug","where","docs","length","OK","user","payloadAuth","betterAuth","api","forgetPassword","redirectTo","headers","Headers"],"mappings":"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"}

package/dist/better-auth/plugin/lib/build-collections/users/endpoints/generate-invite-url.d.ts

@@ -0,0 +1,13 @@
+import { type Endpoint } from "payload";
+import { BetterAuthPluginOptions } from "../../../../types";
+type InviteEndpointProps = {
+    roles: {
+        label: string;
+        value: string;
+    }[];
+    baseUrl: string;
+    pluginOptions: BetterAuthPluginOptions;
+};
+export declare const getGenerateInviteUrlEndpoint: ({ roles, baseUrl, pluginOptions, }: InviteEndpointProps) => Endpoint;
+export {};
+//# sourceMappingURL=generate-invite-url.d.ts.map

package/dist/better-auth/plugin/lib/build-collections/users/endpoints/generate-invite-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-invite-url.d.ts","sourceRoot":"","sources":["../../../../../../../src/better-auth/plugin/lib/build-collections/users/endpoints/generate-invite-url.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAI5D,KAAK,mBAAmB,GAAG;IACzB,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,uBAAuB,CAAC;CACxC,CAAC;AAEF,eAAO,MAAM,4BAA4B,GAAI,oCAI1C,mBAAmB,KAAG,QAoExB,CAAC"}

package/dist/better-auth/plugin/lib/build-collections/users/endpoints/generate-invite-url.js

@@ -0,0 +1,67 @@
+import { status as httpStatus } from "http-status";
+import { addDataAndFileToRequest } from "payload";
+import { generateAdminInviteUrl } from "../../../../payload/utils/generate-admin-invite-url";
+export const getGenerateInviteUrlEndpoint = ({ roles, baseUrl, pluginOptions })=>{
+    const endpoint = {
+        path: "/generate-invite-url",
+        method: "post",
+        handler: async (req)=>{
+            await addDataAndFileToRequest(req);
+            const body = req.data;
+            const generateAdminInviteUrlFn = pluginOptions?.adminInvitations?.generateInviteUrl ?? generateAdminInviteUrl;
+            if (!body) {
+                return Response.json({
+                    message: "No body provided"
+                }, {
+                    status: httpStatus.BAD_REQUEST
+                });
+            }
+            if (typeof body !== "object" || !("role" in body)) {
+                return Response.json({
+                    message: "Invalid body"
+                }, {
+                    status: httpStatus.BAD_REQUEST
+                });
+            }
+            if (!roles.some((role)=>role.value === body.role.value)) {
+                return Response.json({
+                    message: "Invalid role"
+                }, {
+                    status: httpStatus.BAD_REQUEST
+                });
+            }
+            const token = crypto.randomUUID();
+            const inviteLink = generateAdminInviteUrlFn({
+                payload: req.payload,
+                token
+            });
+            try {
+                await req.payload.create({
+                    collection: pluginOptions.adminInvitations?.slug ?? "admin-invitations",
+                    data: {
+                        token,
+                        role: body.role.value,
+                        url: inviteLink
+                    }
+                });
+                const response = new Response(JSON.stringify({
+                    message: "Invite link generated successfully",
+                    inviteLink
+                }), {
+                    status: 200
+                });
+                return response;
+            } catch (error) {
+                console.error(error);
+                return Response.json({
+                    message: "Error generating invite link"
+                }, {
+                    status: httpStatus.INTERNAL_SERVER_ERROR
+                });
+            }
+        }
+    };
+    return endpoint;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/lib/build-collections/users/endpoints/login.d.ts

@@ -0,0 +1,4 @@
+import { type Endpoint } from "payload";
+import { SanitizedBetterAuthOptions } from "../../../../types";
+export declare const getLoginEndpoint: (betterAuthOptions: SanitizedBetterAuthOptions) => Endpoint;
+//# sourceMappingURL=login.d.ts.map

package/dist/better-auth/plugin/lib/build-collections/users/endpoints/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../../../../../../src/better-auth/plugin/lib/build-collections/users/endpoints/login.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEjE,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAW/D,eAAO,MAAM,gBAAgB,GAC3B,mBAAmB,0BAA0B,KAC5C,QAoHF,CAAC"}

package/dist/better-auth/plugin/lib/build-collections/users/endpoints/login.js

@@ -0,0 +1,115 @@
+import { addDataAndFileToRequest } from "payload";
+import { status as httpStatus } from "http-status";
+import z from "zod";
+import { getRequestCollection } from "../../../../helpers/get-requst-collection";
+const loginSchema = z.object({
+    password: z.string(),
+    email: z.string().email().optional(),
+    username: z.string().optional()
+});
+export const getLoginEndpoint = (betterAuthOptions)=>{
+    const endpoint = {
+        path: "/login",
+        method: "post",
+        handler: async (req)=>{
+            await addDataAndFileToRequest(req);
+            const collection = getRequestCollection(req);
+            const { t } = req;
+            try {
+                const schema = loginSchema.safeParse(req.data);
+                if (!schema.success) {
+                    return Response.json({
+                        message: schema.error.message
+                    }, {
+                        status: httpStatus.BAD_REQUEST
+                    });
+                }
+                console.log("schema.data", schema.data);
+                let { email, password, username } = schema.data;
+                // If the username looks like an email, it might be using
+                // the emailOrUsername field type, so we should set email accordingly
+                //TODO: CHECK IF THIS IS CORRECT, username could have an @??
+                if (username && !email && username.includes("@")) {
+                    email = username;
+                    username = undefined;
+                }
+                let result;
+                const baseURL = betterAuthOptions.baseURL;
+                const basePath = betterAuthOptions.basePath ?? "/api/auth";
+                const authApiURL = `${baseURL}${basePath}`;
+                if (username) {
+                    const url = authApiURL + "/sign-in/username";
+                    result = await fetch(url, {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json"
+                        },
+                        body: JSON.stringify({
+                            username,
+                            password
+                        })
+                    });
+                } else {
+                    const url = authApiURL + "/sign-in/email";
+                    result = await fetch(url, {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json"
+                        },
+                        body: JSON.stringify({
+                            email,
+                            password
+                        })
+                    });
+                }
+                // console.log("result", result);
+                const ok = result.ok;
+                const responseData = await result.json();
+                if (!ok) {
+                    // check if its
+                    if (responseData.code === "EMAIL_NOT_VERIFIED") {
+                        return new Response(JSON.stringify({
+                            message: t("authentication:verifyYourEmail"),
+                            sentEmailVerification: true,
+                            requireEmailVerification: true
+                        }), {
+                            status: httpStatus.FORBIDDEN
+                        });
+                    } else {
+                        return new Response(JSON.stringify({
+                            message: "Failed to login"
+                        }), {
+                            status: httpStatus.UNAUTHORIZED
+                        });
+                    }
+                }
+                // Create the response with the appropriate data
+                const response = new Response(JSON.stringify({
+                    message: t("authentication:passed"),
+                    ...responseData
+                }), {
+                    status: 200
+                });
+                // Forward all Set-Cookie headers from the original response to our response
+                const setCookieHeader = result.headers.get("set-cookie");
+                if (setCookieHeader) {
+                    // Set-Cookie headers are typically returned as a single string with multiple cookies separated by commas
+                    const cookies = setCookieHeader.split(",");
+                    cookies.forEach((cookie)=>{
+                        response.headers.append("Set-Cookie", cookie.trim());
+                    });
+                }
+                return response;
+            } catch (error) {
+                return Response.json({
+                    message: "Failed to login"
+                }, {
+                    status: httpStatus.INTERNAL_SERVER_ERROR
+                });
+            }
+        }
+    };
+    return endpoint;
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../../src/better-auth/plugin/lib/build-collections/users/endpoints/login.ts"],"sourcesContent":["import { addDataAndFileToRequest, type Endpoint } from \"payload\";\nimport { status as httpStatus } from \"http-status\";\nimport { SanitizedBetterAuthOptions } from \"../../../../types\";\nimport z from \"zod\";\nimport { getRequestCollection } from \"../../../../helpers/get-requst-collection\";\nimport { InferErrorCodes } from \"better-auth\";\n\nconst loginSchema = z.object({\n  password: z.string(),\n  email: z.string().email().optional(),\n  username: z.string().optional(),\n});\n\nexport const getLoginEndpoint = (\n  betterAuthOptions: SanitizedBetterAuthOptions\n): Endpoint => {\n  const endpoint: Endpoint = {\n    path: \"/login\",\n    method: \"post\",\n    handler: async (req) => {\n      await addDataAndFileToRequest(req);\n      const collection = getRequestCollection(req);\n\n      const { t } = req;\n\n      try {\n        const schema = loginSchema.safeParse(req.data);\n\n        if (!schema.success) {\n          return Response.json(\n            { message: schema.error.message },\n            { status: httpStatus.BAD_REQUEST }\n          );\n        }\n\n        console.log(\"schema.data\", schema.data);\n\n        let { email, password, username } = schema.data;\n\n        // If the username looks like an email, it might be using\n        // the emailOrUsername field type, so we should set email accordingly\n        //TODO: CHECK IF THIS IS CORRECT, username could have an @??\n        if (username && !email && username.includes(\"@\")) {\n          email = username;\n          username = undefined;\n        }\n\n        let result;\n        const baseURL = betterAuthOptions.baseURL;\n        const basePath = betterAuthOptions.basePath ?? \"/api/auth\";\n        const authApiURL = `${baseURL}${basePath}`;\n\n        if (username) {\n          const url = authApiURL + \"/sign-in/username\";\n          result = await fetch(url, {\n            method: \"POST\",\n            headers: {\n              \"Content-Type\": \"application/json\",\n            },\n            body: JSON.stringify({\n              username,\n              password,\n            }),\n          });\n        } else {\n          const url = authApiURL + \"/sign-in/email\";\n          result = await fetch(url, {\n            method: \"POST\",\n            headers: {\n              \"Content-Type\": \"application/json\",\n            },\n            body: JSON.stringify({\n              email,\n              password,\n            }),\n          });\n        }\n        // console.log(\"result\", result);\n        const ok = result.ok;\n        const responseData = await result.json();\n        if (!ok) {\n          // check if its\n          if (responseData.code === \"EMAIL_NOT_VERIFIED\") {\n            return new Response(\n              JSON.stringify({\n                message: t(\"authentication:verifyYourEmail\"),\n                sentEmailVerification: true,\n                requireEmailVerification: true,\n              }),\n              { status: httpStatus.FORBIDDEN }\n            );\n          } else {\n            return new Response(\n              JSON.stringify({\n                message: \"Failed to login\",\n              }),\n              { status: httpStatus.UNAUTHORIZED }\n            );\n          }\n        }\n\n        // Create the response with the appropriate data\n        const response = new Response(\n          JSON.stringify({\n            message: t(\"authentication:passed\"),\n            ...responseData,\n          }),\n          {\n            status: 200,\n          }\n        );\n        // Forward all Set-Cookie headers from the original response to our response\n        const setCookieHeader = result.headers.get(\"set-cookie\");\n        if (setCookieHeader) {\n          // Set-Cookie headers are typically returned as a single string with multiple cookies separated by commas\n          const cookies = setCookieHeader.split(\",\");\n          cookies.forEach((cookie) => {\n            response.headers.append(\"Set-Cookie\", cookie.trim());\n          });\n        }\n        return response;\n      } catch (error) {\n        return Response.json(\n          { message: \"Failed to login\" },\n          { status: httpStatus.INTERNAL_SERVER_ERROR }\n        );\n      }\n    },\n  };\n\n  return endpoint;\n};\n"],"names":["addDataAndFileToRequest","status","httpStatus","z","getRequestCollection","loginSchema","object","password","string","email","optional","username","getLoginEndpoint","betterAuthOptions","endpoint","path","method","handler","req","collection","t","schema","safeParse","data","success","Response","json","message","error","BAD_REQUEST","console","log","includes","undefined","result","baseURL","basePath","authApiURL","url","fetch","headers","body","JSON","stringify","ok","responseData","code","sentEmailVerification","requireEmailVerification","FORBIDDEN","UNAUTHORIZED","response","setCookieHeader","get","cookies","split","forEach","cookie","append","trim","INTERNAL_SERVER_ERROR"],"mappings":"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"}

package/dist/better-auth/plugin/lib/build-collections/users/endpoints/refresh-token.d.ts

@@ -0,0 +1,3 @@
+import { type Endpoint } from "payload";
+export declare const getRefreshTokenEndpoint: (userSlug: string) => Endpoint;
+//# sourceMappingURL=refresh-token.d.ts.map

package/dist/better-auth/plugin/lib/build-collections/users/endpoints/refresh-token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refresh-token.d.ts","sourceRoot":"","sources":["../../../../../../../src/better-auth/plugin/lib/build-collections/users/endpoints/refresh-token.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,QAAQ,EAId,MAAM,SAAS,CAAC;AAIjB,eAAO,MAAM,uBAAuB,GAAI,UAAU,MAAM,KAAG,QAmH1D,CAAC"}

package/dist/better-auth/plugin/lib/build-collections/users/endpoints/refresh-token.js

@@ -0,0 +1,110 @@
+import { setCookieCache } from "better-auth/cookies";
+import { getFieldsToSign, refreshOperation } from "payload";
+import { getPayloadAuth } from "../../../../lib/get-payload-auth";
+export const getRefreshTokenEndpoint = (userSlug)=>{
+    const endpoint = {
+        path: "/refresh-token",
+        method: "post",
+        handler: async (req)=>{
+            const payload = await getPayloadAuth(req.payload.config);
+            const authContext = await payload.betterAuth?.$context;
+            const userCollection = payload.collections[userSlug];
+            if (!userCollection) {
+                return new Response(JSON.stringify({
+                    message: "User collection not found"
+                }), {
+                    status: 500
+                });
+            }
+            if (!payload.betterAuth || !authContext) {
+                return new Response(JSON.stringify({
+                    message: "BetterAuth not initialized"
+                }), {
+                    status: 500
+                });
+            }
+            const sessionTokenName = authContext.authCookies.sessionToken.name;
+            const cookieHeader = req.headers.get("cookie") || "";
+            const hasSessionToken = cookieHeader.includes(`${sessionTokenName}=`);
+            if (!hasSessionToken) {
+                try {
+                    const result = await refreshOperation({
+                        collection: userCollection,
+                        req
+                    });
+                    return new Response(JSON.stringify(result), {
+                        status: 200
+                    });
+                } catch (error) {
+                    console.error("Token refresh failed:", error);
+                    return new Response(JSON.stringify({
+                        message: "Token refresh failed"
+                    }), {
+                        status: 401
+                    });
+                }
+            }
+            const res = await payload.betterAuth.api.getSession({
+                headers: req.headers,
+                query: {
+                    disableCookieCache: true
+                }
+            });
+            if (!res) {
+                return new Response(JSON.stringify({
+                    message: "No current session"
+                }), {
+                    status: 401
+                });
+            }
+            const user = await payload.findByID({
+                collection: userSlug,
+                id: res.session.userId
+            });
+            if (!user) {
+                return new Response(JSON.stringify({
+                    message: "No user found"
+                }), {
+                    status: 401
+                });
+            }
+            const cookieCacheFields = getFieldsToSign({
+                collectionConfig: userCollection?.config,
+                email: user.email,
+                user: user
+            });
+            const responseData = {
+                refreshedToken: null,
+                setCookie: !!authContext.options.session?.cookieCache?.enabled,
+                strategy: "better-auth",
+                user: {
+                    ...user,
+                    collection: userSlug
+                }
+            };
+            const response = new Response(JSON.stringify(responseData), {
+                status: 200
+            });
+            const ctx = {
+                context: authContext,
+                setCookie (name, value, options) {
+                    const path = options?.path || "/";
+                    const maxAge = options?.maxAge ? `; Max-Age=${options.maxAge}` : "";
+                    const httpOnly = options?.httpOnly ? "; HttpOnly" : "";
+                    const secure = options?.secure ? "; Secure" : "";
+                    const sameSite = options?.sameSite ? `; SameSite=${options.sameSite}` : "; SameSite=Lax";
+                    response.headers.set("Set-Cookie", `${name}=${value}; Path=${path}${maxAge}${httpOnly}${secure}${sameSite}`);
+                    return name;
+                }
+            };
+            await setCookieCache(ctx, {
+                session: res.session,
+                user: cookieCacheFields
+            });
+            return response;
+        }
+    };
+    return endpoint;
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../../src/better-auth/plugin/lib/build-collections/users/endpoints/refresh-token.ts"],"sourcesContent":["import { setCookieCache } from \"better-auth/cookies\";\nimport {\n  CollectionSlug,\n  type Endpoint,\n  getFieldsToSign,\n  refreshOperation,\n  User,\n} from \"payload\";\nimport { GenericEndpointContext } from \"better-auth/types\";\nimport { getPayloadAuth } from \"../../../../lib/get-payload-auth\";\n\nexport const getRefreshTokenEndpoint = (userSlug: string): Endpoint => {\n  const endpoint: Endpoint = {\n    path: \"/refresh-token\",\n    method: \"post\",\n    handler: async (req) => {\n      const payload = await getPayloadAuth(req.payload.config);\n      const authContext = await payload.betterAuth?.$context;\n      const userCollection = payload.collections[userSlug];\n\n      if (!userCollection) {\n        return new Response(\n          JSON.stringify({ message: \"User collection not found\" }),\n          {\n            status: 500,\n          }\n        );\n      }\n\n      if (!payload.betterAuth || !authContext) {\n        return new Response(\n          JSON.stringify({ message: \"BetterAuth not initialized\" }),\n          {\n            status: 500,\n          }\n        );\n      }\n\n      const sessionTokenName = authContext.authCookies.sessionToken.name;\n      const cookieHeader = req.headers.get(\"cookie\") || \"\";\n      const hasSessionToken = cookieHeader.includes(`${sessionTokenName}=`);\n\n      if (!hasSessionToken) {\n        try {\n          const result = await refreshOperation({\n            collection: userCollection,\n            req,\n          });\n          return new Response(JSON.stringify(result), { status: 200 });\n        } catch (error) {\n          console.error(\"Token refresh failed:\", error);\n          return new Response(\n            JSON.stringify({ message: \"Token refresh failed\" }),\n            { status: 401 }\n          );\n        }\n      }\n\n      const res = await payload.betterAuth.api.getSession({\n        headers: req.headers,\n        query: { disableCookieCache: true },\n      });\n\n      if (!res) {\n        return new Response(JSON.stringify({ message: \"No current session\" }), {\n          status: 401,\n        });\n      }\n\n      const user = await payload.findByID({\n        collection: userSlug as string,\n        id: res.session.userId,\n      });\n\n      if (!user) {\n        return new Response(JSON.stringify({ message: \"No user found\" }), {\n          status: 401,\n        });\n      }\n\n      const cookieCacheFields = getFieldsToSign({\n        collectionConfig: userCollection?.config,\n        email: user.email,\n        user: user as User,\n      });\n\n      const responseData = {\n        refreshedToken: null,\n        setCookie: !!authContext.options.session?.cookieCache?.enabled,\n        strategy: \"better-auth\",\n        user: { ...user, collection: userSlug },\n      };\n\n      const response = new Response(JSON.stringify(responseData), {\n        status: 200,\n      });\n\n      const ctx = {\n        context: authContext,\n        setCookie(name, value, options) {\n          const path = options?.path || \"/\";\n          const maxAge = options?.maxAge ? `; Max-Age=${options.maxAge}` : \"\";\n          const httpOnly = options?.httpOnly ? \"; HttpOnly\" : \"\";\n          const secure = options?.secure ? \"; Secure\" : \"\";\n          const sameSite = options?.sameSite\n            ? `; SameSite=${options.sameSite}`\n            : \"; SameSite=Lax\";\n\n          response.headers.set(\n            \"Set-Cookie\",\n            `${name}=${value}; Path=${path}${maxAge}${httpOnly}${secure}${sameSite}`\n          );\n          return name;\n        },\n      } as GenericEndpointContext;\n\n      await setCookieCache(ctx, {\n        session: res.session,\n        user: cookieCacheFields as any,\n      });\n\n      return response;\n    },\n  };\n\n  return endpoint;\n};\n"],"names":["setCookieCache","getFieldsToSign","refreshOperation","getPayloadAuth","getRefreshTokenEndpoint","userSlug","endpoint","path","method","handler","req","payload","config","authContext","betterAuth","$context","userCollection","collections","Response","JSON","stringify","message","status","sessionTokenName","authCookies","sessionToken","name","cookieHeader","headers","get","hasSessionToken","includes","result","collection","error","console","res","api","getSession","query","disableCookieCache","user","findByID","id","session","userId","cookieCacheFields","collectionConfig","email","responseData","refreshedToken","setCookie","options","cookieCache","enabled","strategy","response","ctx","context","value","maxAge","httpOnly","secure","sameSite","set"],"mappings":"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"}