payload-auth 1.0.2 → 1.1.0

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

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

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

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

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

@@ -0,0 +1,62 @@
+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";
+const requestSchema = z.object({
+    token: z.string(),
+    password: z.string()
+});
+export const getResetPasswordEndpoint = ()=>{
+    const endpoint = {
+        path: "/reset-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 { token, password } = body.data;
+            try {
+                const shouldCommit = await initTransaction(req);
+                const payloadAuth = await getPayloadAuth(req.payload.config);
+                const res = await payloadAuth.betterAuth.api.resetPassword({
+                    body: {
+                        token,
+                        newPassword: password
+                    }
+                });
+                if (!res.status) {
+                    throw new APIError("Failed to reset password", httpStatus.INTERNAL_SERVER_ERROR);
+                }
+                if (shouldCommit) {
+                    await commitTransaction(req);
+                }
+                return Response.json({
+                    message: t("authentication:passwordResetSuccessfully")
+                }, {
+                    headers: headersWithCors({
+                        headers: new Headers(),
+                        req
+                    }),
+                    status: httpStatus.OK
+                });
+            } catch (error) {
+                await killTransaction(req);
+                return Response.json({
+                    message: error
+                }, {
+                    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/send-invite-url.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"send-invite-url.d.ts","sourceRoot":"","sources":["../../../../../../../src/better-auth/plugin/lib/build-collections/users/endpoints/send-invite-url.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAGT,MAAM,SAAS,CAAC;AASjB,eAAO,MAAM,wBAAwB,QAAO,QAmC3C,CAAC"}

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

@@ -0,0 +1,42 @@
+import { addDataAndFileToRequest, headersWithCors, killTransaction } from "payload";
+import { status as httpStatus } from "http-status";
+import { z } from "zod";
+const requestSchema = z.object({
+    email: z.string().email(),
+    username: z.string().optional()
+});
+export const getSendInviteUrlEndpoint = ()=>{
+    const endpoint = {
+        path: "/invite/send",
+        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
+                });
+            }
+            try {
+                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,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

package/dist/better-auth/plugin/lib/build-collections/users/endpoints/set-admin-role.d.ts

@@ -0,0 +1,4 @@
+import { type Endpoint } from "payload";
+import { BetterAuthPluginOptions } from "../../../../types";
+export declare const getSetAdminRoleEndpoint: (pluginOptions: BetterAuthPluginOptions, userSlug: string) => Endpoint;
+//# sourceMappingURL=set-admin-role.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"set-admin-role.d.ts","sourceRoot":"","sources":["../../../../../../../src/better-auth/plugin/lib/build-collections/users/endpoints/set-admin-role.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAS5D,eAAO,MAAM,uBAAuB,GAClC,eAAe,uBAAuB,EACtC,UAAU,MAAM,KACf,QAiEF,CAAC"}

package/dist/better-auth/plugin/lib/build-collections/users/endpoints/set-admin-role.js

@@ -0,0 +1,79 @@
+import { status as httpStatus } from "http-status";
+import { getPayloadAuth } from "../../../get-payload-auth";
+import { z } from "zod";
+const setAdminRoleSchema = z.object({
+    token: z.string().optional(),
+    redirect: z.string().optional()
+});
+export const getSetAdminRoleEndpoint = (pluginOptions, userSlug)=>{
+    const endpoint = {
+        path: "/set-admin-role",
+        method: "get",
+        handler: async (req)=>{
+            const { config } = req.payload;
+            const schema = setAdminRoleSchema.safeParse(req.query);
+            if (!schema.success) {
+                return Response.json({
+                    message: schema.error.message
+                }, {
+                    status: httpStatus.BAD_REQUEST
+                });
+            }
+            const payloadAuth = await getPayloadAuth(config);
+            const session = await payloadAuth.betterAuth.api.getSession({
+                headers: req.headers
+            });
+            if (!session) {
+                return Response.json({
+                    message: "No session found"
+                }, {
+                    status: httpStatus.UNAUTHORIZED
+                });
+            }
+            const { token, redirect } = schema.data;
+            const invite = await req.payload.find({
+                collection: pluginOptions.adminInvitations?.slug ?? "admin-invitations",
+                where: {
+                    token: {
+                        equals: token
+                    }
+                },
+                limit: 1
+            });
+            if (invite.docs.length === 0) {
+                return Response.json({
+                    message: "Invalid token"
+                }, {
+                    status: httpStatus.UNAUTHORIZED
+                });
+            }
+            const role = invite.docs[0].role;
+            const updatedUser = await req.payload.update({
+                collection: userSlug,
+                id: session.user.id,
+                data: {
+                    role: role
+                },
+                overrideAccess: true
+            });
+            await req.payload.delete({
+                collection: pluginOptions.adminInvitations?.slug ?? "admin-invitations",
+                where: {
+                    token: {
+                        equals: token
+                    }
+                }
+            });
+            const response = new Response(null, {
+                status: 307,
+                headers: {
+                    Location: redirect ?? config.routes.admin
+                }
+            });
+            return response;
+        }
+    };
+    return endpoint;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"signup.d.ts","sourceRoot":"","sources":["../../../../../../../src/better-auth/plugin/lib/build-collections/users/endpoints/signup.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,uBAAuB,EACvB,0BAA0B,EAC3B,MAAM,mBAAmB,CAAC;AAgB3B,eAAO,MAAM,iBAAiB,GAC5B,eAAe,uBAAuB,EACtC,mBAAmB,0BAA0B,KAC5C,QAyJF,CAAC"}

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

@@ -0,0 +1,153 @@
+import { addDataAndFileToRequest, commitTransaction, initTransaction, killTransaction } from "payload";
+import { status as httpStatus } from "http-status";
+import z from "zod";
+import { getRequestCollection } from "../../../../helpers/get-requst-collection";
+const routeParamsSchema = z.object({
+    token: z.string(),
+    redirect: z.string().optional()
+});
+const signupSchema = z.object({
+    password: z.string(),
+    email: z.string().email(),
+    username: z.string().optional()
+});
+export const getSignupEndpoint = (pluginOptions, betterAuthOptions)=>{
+    const endpoint = {
+        path: "/signup",
+        method: "post",
+        handler: async (req)=>{
+            await addDataAndFileToRequest(req);
+            const collection = getRequestCollection(req);
+            const { t } = req;
+            try {
+                const shouldCommit = await initTransaction(req);
+                const { success: routeParamsSuccess, data: routeParamsData, error: routeParamsError } = routeParamsSchema.safeParse(req.query);
+                if (!routeParamsSuccess) {
+                    return Response.json({
+                        message: routeParamsError.message
+                    }, {
+                        status: httpStatus.BAD_REQUEST
+                    });
+                }
+                const invite = await req.payload.find({
+                    collection: pluginOptions.adminInvitations?.slug ?? "admin-invitations",
+                    where: {
+                        token: {
+                            equals: routeParamsData.token
+                        }
+                    },
+                    limit: 1,
+                    req
+                });
+                if (invite.docs.length === 0) {
+                    return Response.json({
+                        message: "Invalid token"
+                    }, {
+                        status: httpStatus.UNAUTHORIZED
+                    });
+                }
+                const inviteRole = invite.docs[0].role;
+                const schema = signupSchema.safeParse(req.data);
+                if (!schema.success) {
+                    return Response.json({
+                        message: schema.error.message
+                    }, {
+                        status: httpStatus.BAD_REQUEST
+                    });
+                }
+                const { email, password, username } = schema.data;
+                const baseURL = betterAuthOptions.baseURL;
+                const basePath = betterAuthOptions.basePath ?? "/api/auth";
+                const authApiURL = `${baseURL}${basePath}`;
+                const url = authApiURL + "/sign-up/email";
+                const result = await fetch(url, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json"
+                    },
+                    body: JSON.stringify({
+                        email: email,
+                        password: password,
+                        username: username
+                    })
+                });
+                const ok = result.ok;
+                if (!ok) {
+                    throw new Error(result.statusText);
+                }
+                const responseData = await result.json();
+                await req.payload.update({
+                    collection: pluginOptions.users?.slug ?? "users",
+                    id: responseData.user.id,
+                    data: {
+                        role: inviteRole
+                    },
+                    overrideAccess: true,
+                    req
+                });
+                await req.payload.delete({
+                    collection: pluginOptions.adminInvitations?.slug ?? "admin-invitations",
+                    where: {
+                        token: {
+                            equals: routeParamsData.token
+                        }
+                    },
+                    req
+                });
+                const requireEmailVerification = (betterAuthOptions.emailAndPassword?.requireEmailVerification || collection.config.auth.verify) && !responseData.user.emailVerified;
+                const sentEmailVerification = betterAuthOptions.emailVerification?.sendVerificationEmail !== undefined;
+                if (requireEmailVerification) {
+                    if (shouldCommit) {
+                        await commitTransaction(req);
+                    }
+                    if (sentEmailVerification) {
+                        return new Response(JSON.stringify({
+                            message: t("authentication:verifyYourEmail"),
+                            sentEmailVerification,
+                            requireEmailVerification
+                        }), {
+                            status: httpStatus.UNAUTHORIZED
+                        });
+                    } else {
+                        return new Response(JSON.stringify({
+                            message: t("authentication:verifyYourEmail"),
+                            sentEmailVerification,
+                            requireEmailVerification
+                        }), {
+                            status: httpStatus.UNAUTHORIZED
+                        });
+                    }
+                }
+                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());
+                    });
+                }
+                if (shouldCommit) {
+                    await commitTransaction(req);
+                }
+                return response;
+            } catch (error) {
+                await killTransaction(req);
+                return Response.json({
+                    message: error.message
+                }, {
+                    status: httpStatus.INTERNAL_SERVER_ERROR
+                });
+            }
+        }
+    };
+    return endpoint;
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../../src/better-auth/plugin/lib/build-collections/users/endpoints/signup.ts"],"sourcesContent":["import {\n  addDataAndFileToRequest,\n  commitTransaction,\n  initTransaction,\n  killTransaction,\n  type Endpoint,\n} from \"payload\";\nimport { status as httpStatus } from \"http-status\";\nimport {\n  BetterAuthPluginOptions,\n  SanitizedBetterAuthOptions,\n} from \"../../../../types\";\nimport z from \"zod\";\nimport { getPayloadAuth } from \"../../../get-payload-auth\";\nimport { getRequestCollection } from \"../../../../helpers/get-requst-collection\";\n\nconst routeParamsSchema = z.object({\n  token: z.string(),\n  redirect: z.string().optional(),\n});\n\nconst signupSchema = z.object({\n  password: z.string(),\n  email: z.string().email(),\n  username: z.string().optional(),\n});\n\nexport const getSignupEndpoint = (\n  pluginOptions: BetterAuthPluginOptions,\n  betterAuthOptions: SanitizedBetterAuthOptions\n): Endpoint => {\n  const endpoint: Endpoint = {\n    path: \"/signup\",\n    method: \"post\",\n    handler: async (req) => {\n      await addDataAndFileToRequest(req);\n      const collection = getRequestCollection(req);\n      const { t } = req;\n      try {\n        const shouldCommit = await initTransaction(req);\n        const {\n          success: routeParamsSuccess,\n          data: routeParamsData,\n          error: routeParamsError,\n        } = routeParamsSchema.safeParse(req.query);\n        if (!routeParamsSuccess) {\n          return Response.json(\n            { message: routeParamsError.message },\n            { status: httpStatus.BAD_REQUEST }\n          );\n        }\n        const invite = await req.payload.find({\n          collection:\n            pluginOptions.adminInvitations?.slug ?? \"admin-invitations\",\n          where: {\n            token: {\n              equals: routeParamsData.token,\n            },\n          },\n          limit: 1,\n          req,\n        });\n        if (invite.docs.length === 0) {\n          return Response.json(\n            { message: \"Invalid token\" },\n            { status: httpStatus.UNAUTHORIZED }\n          );\n        }\n        const inviteRole = invite.docs[0].role as string;\n        const schema = signupSchema.safeParse(req.data);\n        if (!schema.success) {\n          return Response.json(\n            { message: schema.error.message },\n            { status: httpStatus.BAD_REQUEST }\n          );\n        }\n        const { email, password, username } = schema.data;\n        const baseURL = betterAuthOptions.baseURL;\n        const basePath = betterAuthOptions.basePath ?? \"/api/auth\";\n        const authApiURL = `${baseURL}${basePath}`;\n        const url = authApiURL + \"/sign-up/email\";\n        const result = await fetch(url, {\n          method: \"POST\",\n          headers: {\n            \"Content-Type\": \"application/json\",\n          },\n          body: JSON.stringify({\n            email: email,\n            password: password,\n            username: username,\n          }),\n        });\n        const ok = result.ok;\n\n        if (!ok) {\n          throw new Error(result.statusText);\n        }\n        const responseData = await result.json();\n\n        await req.payload.update({\n          collection: pluginOptions.users?.slug ?? \"users\",\n          id: responseData.user.id,\n          data: {\n            role: inviteRole,\n          },\n          overrideAccess: true,\n          req,\n        });\n        await req.payload.delete({\n          collection:\n            pluginOptions.adminInvitations?.slug ?? \"admin-invitations\",\n          where: {\n            token: { equals: routeParamsData.token },\n          },\n          req,\n        });\n\n        const requireEmailVerification =\n          (betterAuthOptions.emailAndPassword?.requireEmailVerification ||\n            collection.config.auth.verify) &&\n          !responseData.user.emailVerified;\n\n        const sentEmailVerification =\n          betterAuthOptions.emailVerification?.sendVerificationEmail !==\n          undefined;\n\n        if (requireEmailVerification) {\n          if (shouldCommit) {\n            await commitTransaction(req);\n          }\n          if (sentEmailVerification) {\n            return new Response(\n              JSON.stringify({\n                message: t(\"authentication:verifyYourEmail\"),\n                sentEmailVerification,\n                requireEmailVerification,\n              }),\n              { status: httpStatus.UNAUTHORIZED }\n            );\n          } else {\n            return new Response(\n              JSON.stringify({\n                message: t(\"authentication:verifyYourEmail\"),\n                sentEmailVerification,\n                requireEmailVerification,\n              }),\n              { status: httpStatus.UNAUTHORIZED }\n            );\n          }\n        }\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        if (shouldCommit) {\n          await commitTransaction(req);\n        }\n        return response;\n      } catch (error: any) {\n        await killTransaction(req);\n        return Response.json(\n          { message: error.message },\n          { status: httpStatus.INTERNAL_SERVER_ERROR }\n        );\n      }\n    },\n  };\n\n  return endpoint;\n};\n"],"names":["addDataAndFileToRequest","commitTransaction","initTransaction","killTransaction","status","httpStatus","z","getRequestCollection","routeParamsSchema","object","token","string","redirect","optional","signupSchema","password","email","username","getSignupEndpoint","pluginOptions","betterAuthOptions","endpoint","path","method","handler","req","collection","t","shouldCommit","success","routeParamsSuccess","data","routeParamsData","error","routeParamsError","safeParse","query","Response","json","message","BAD_REQUEST","invite","payload","find","adminInvitations","slug","where","equals","limit","docs","length","UNAUTHORIZED","inviteRole","role","schema","baseURL","basePath","authApiURL","url","result","fetch","headers","body","JSON","stringify","ok","Error","statusText","responseData","update","users","id","user","overrideAccess","delete","requireEmailVerification","emailAndPassword","config","auth","verify","emailVerified","sentEmailVerification","emailVerification","sendVerificationEmail","undefined","response","setCookieHeader","get","cookies","split","forEach","cookie","append","trim","INTERNAL_SERVER_ERROR"],"mappings":"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"}

package/dist/better-auth/plugin/{collections → lib/build-collections}/users/hooks/after-login.d.ts

@@ -1,4 +1,4 @@
-import { CollectionAfterLoginHook } from 'payload';
+import { CollectionAfterLoginHook } from "payload";
 type AfterLoginOptions = {
     usersCollectionSlug: string;
     sessionsCollectionSlug: string;

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

@@ -0,0 +1 @@
+{"version":3,"file":"after-login.d.ts","sourceRoot":"","sources":["../../../../../../../src/better-auth/plugin/lib/build-collections/users/hooks/after-login.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAKnD,KAAK,iBAAiB,GAAG;IACvB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,sBAAsB,EAAE,MAAM,CAAC;CAChC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAC5B,SAAS,iBAAiB,KACzB,wBA8EF,CAAC"}

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

@@ -0,0 +1,75 @@
+import { generateId } from "better-auth";
+import { createAuthMiddleware } from "better-auth/api";
+import { setCookieCache } from "better-auth/cookies";
+import { parseSetCookie } from "next/dist/compiled/@edge-runtime/cookies";
+import { cookies } from "next/headers";
+import { getPayloadAuth } from "../../../../lib/get-payload-auth";
+import { getIp } from "../../../../helpers/get-ip";
+import { prepareSessionData } from "../../../../helpers/prepare-session-data";
+/**
+ * This hook is used to sync the admin login token with better-auth session token
+ * It also creates a new session in better-auth
+ */ export const getAfterLoginHook = (options)=>{
+    const hook = async ({ collection, context, req, token, user })=>{
+        const config = req.payload.config;
+        const payload = await getPayloadAuth(config);
+        const cookieStore = await cookies();
+        const authContext = await payload.betterAuth.$context;
+        const sessionExpiration = payload.betterAuth.options.session?.expiresIn || 60 * 60 * 24 * 7; // 7 days
+        // we can't use internal adapter as we can cause a race condition unless we pass req to the payload.create
+        const session = await payload.create({
+            collection: options.sessionsCollectionSlug,
+            data: {
+                ipAddress: getIp(req.headers, payload.betterAuth.options) || "",
+                userAgent: req.headers?.get("user-agent") || "",
+                user: user.id,
+                token: generateId(32),
+                expiresAt: new Date(Date.now() + sessionExpiration * 1000)
+            },
+            req
+        });
+        const betterAuthHandleRequest = createAuthMiddleware(async (ctx)=>{
+            ctx.context = {
+                ...authContext,
+                user: user
+            };
+            await ctx.setSignedCookie(ctx.context.authCookies.sessionToken.name, session.token, ctx.context.secret, ctx.context.authCookies.sessionToken.options);
+            const filteredSessionData = await prepareSessionData({
+                newSession: {
+                    session,
+                    user
+                },
+                payloadConfig: config,
+                collectionSlugs: {
+                    userCollectionSlug: options.usersCollectionSlug,
+                    sessionCollectionSlug: options.sessionsCollectionSlug
+                }
+            });
+            await setCookieCache(ctx, filteredSessionData);
+            if ("responseHeaders" in ctx) {
+                return ctx.responseHeaders;
+            }
+            return null;
+        });
+        // Create a modified request object that matches the expected MiddlewareInputContext type
+        const modifiedReq = {
+            ...req,
+            body: undefined // Explicitly set body to undefined to satisfy type constraint
+        };
+        const responseHeaders = await betterAuthHandleRequest(modifiedReq);
+        const responseCookies = responseHeaders?.getSetCookie().map((cookie)=>parseSetCookie(cookie)).filter(Boolean);
+        if (responseCookies) {
+            for (const cookieData of responseCookies){
+                const { name, value, ...options } = cookieData;
+                cookieStore.set({
+                    ...options,
+                    name,
+                    value: decodeURIComponent(value)
+                });
+            }
+        }
+    };
+    return hook;
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../../src/better-auth/plugin/lib/build-collections/users/hooks/after-login.ts"],"sourcesContent":["import { generateId, Session } from \"better-auth\";\nimport { createAuthMiddleware } from \"better-auth/api\";\nimport { setCookieCache } from \"better-auth/cookies\";\nimport {\n  parseSetCookie,\n  type ResponseCookie,\n} from \"next/dist/compiled/@edge-runtime/cookies\";\nimport { cookies } from \"next/headers\";\nimport { CollectionAfterLoginHook } from \"payload\";\nimport { getPayloadAuth } from \"../../../../lib/get-payload-auth\";\nimport { getIp } from \"../../../../helpers/get-ip\";\nimport { prepareSessionData } from \"../../../../helpers/prepare-session-data\";\n\ntype AfterLoginOptions = {\n  usersCollectionSlug: string;\n  sessionsCollectionSlug: string;\n};\n\n/**\n * This hook is used to sync the admin login token with better-auth session token\n * It also creates a new session in better-auth\n */\nexport const getAfterLoginHook = (\n  options: AfterLoginOptions\n): CollectionAfterLoginHook => {\n  const hook: CollectionAfterLoginHook = async ({\n    collection,\n    context,\n    req,\n    token,\n    user,\n  }) => {\n    const config = req.payload.config;\n    const payload = await getPayloadAuth(config);\n    const cookieStore = await cookies();\n    const authContext = await payload.betterAuth.$context;\n\n    const sessionExpiration =\n      payload.betterAuth.options.session?.expiresIn || 60 * 60 * 24 * 7; // 7 days\n    // we can't use internal adapter as we can cause a race condition unless we pass req to the payload.create\n    const session = (await payload.create({\n      collection: options.sessionsCollectionSlug,\n      data: {\n        ipAddress: getIp(req.headers, payload.betterAuth.options) || \"\",\n        userAgent: req.headers?.get(\"user-agent\") || \"\",\n        user: user.id,\n        token: generateId(32),\n        expiresAt: new Date(Date.now() + sessionExpiration * 1000),\n      },\n      req,\n    })) as Session;\n\n    const betterAuthHandleRequest = createAuthMiddleware(\n      async (ctx): Promise<Headers | null> => {\n        ctx.context = { ...authContext, user: user };\n        await ctx.setSignedCookie(\n          ctx.context.authCookies.sessionToken.name,\n          session.token,\n          ctx.context.secret,\n          ctx.context.authCookies.sessionToken.options\n        );\n        const filteredSessionData = await prepareSessionData({\n          newSession: { session, user },\n          payloadConfig: config,\n          collectionSlugs: {\n            userCollectionSlug: options.usersCollectionSlug,\n            sessionCollectionSlug: options.sessionsCollectionSlug,\n          },\n        });\n        await setCookieCache(ctx, filteredSessionData as any);\n        if (\"responseHeaders\" in ctx) {\n          return ctx.responseHeaders as Headers;\n        }\n        return null;\n      }\n    );\n\n    // Create a modified request object that matches the expected MiddlewareInputContext type\n    const modifiedReq = {\n      ...req,\n      body: undefined // Explicitly set body to undefined to satisfy type constraint\n    };\n    \n    const responseHeaders = await betterAuthHandleRequest(modifiedReq);\n    const responseCookies = responseHeaders\n      ?.getSetCookie()\n      .map((cookie) => parseSetCookie(cookie))\n      .filter(Boolean) as ResponseCookie[];\n\n    if (responseCookies) {\n      for (const cookieData of responseCookies) {\n        const { name, value, ...options } = cookieData;\n        cookieStore.set({\n          ...options,\n          name,\n          value: decodeURIComponent(value),\n        });\n      }\n    }\n  };\n\n  return hook as CollectionAfterLoginHook;\n};\n"],"names":["generateId","createAuthMiddleware","setCookieCache","parseSetCookie","cookies","getPayloadAuth","getIp","prepareSessionData","getAfterLoginHook","options","hook","collection","context","req","token","user","config","payload","cookieStore","authContext","betterAuth","$context","sessionExpiration","session","expiresIn","create","sessionsCollectionSlug","data","ipAddress","headers","userAgent","get","id","expiresAt","Date","now","betterAuthHandleRequest","ctx","setSignedCookie","authCookies","sessionToken","name","secret","filteredSessionData","newSession","payloadConfig","collectionSlugs","userCollectionSlug","usersCollectionSlug","sessionCollectionSlug","responseHeaders","modifiedReq","body","undefined","responseCookies","getSetCookie","map","cookie","filter","Boolean","cookieData","value","set","decodeURIComponent"],"mappings":"AAAA,SAASA,UAAU,QAAiB,cAAc;AAClD,SAASC,oBAAoB,QAAQ,kBAAkB;AACvD,SAASC,cAAc,QAAQ,sBAAsB;AACrD,SACEC,cAAc,QAET,2CAA2C;AAClD,SAASC,OAAO,QAAQ,eAAe;AAEvC,SAASC,cAAc,QAAQ,mCAAmC;AAClE,SAASC,KAAK,QAAQ,6BAA6B;AACnD,SAASC,kBAAkB,QAAQ,2CAA2C;AAO9E;;;CAGC,GACD,OAAO,MAAMC,oBAAoB,CAC/BC;IAEA,MAAMC,OAAiC,OAAO,EAC5CC,UAAU,EACVC,OAAO,EACPC,GAAG,EACHC,KAAK,EACLC,IAAI,EACL;QACC,MAAMC,SAASH,IAAII,OAAO,CAACD,MAAM;QACjC,MAAMC,UAAU,MAAMZ,eAAeW;QACrC,MAAME,cAAc,MAAMd;QAC1B,MAAMe,cAAc,MAAMF,QAAQG,UAAU,CAACC,QAAQ;QAErD,MAAMC,oBACJL,QAAQG,UAAU,CAACX,OAAO,CAACc,OAAO,EAAEC,aAAa,KAAK,KAAK,KAAK,GAAG,SAAS;QAC9E,0GAA0G;QAC1G,MAAMD,UAAW,MAAMN,QAAQQ,MAAM,CAAC;YACpCd,YAAYF,QAAQiB,sBAAsB;YAC1CC,MAAM;gBACJC,WAAWtB,MAAMO,IAAIgB,OAAO,EAAEZ,QAAQG,UAAU,CAACX,OAAO,KAAK;gBAC7DqB,WAAWjB,IAAIgB,OAAO,EAAEE,IAAI,iBAAiB;gBAC7ChB,MAAMA,KAAKiB,EAAE;gBACblB,OAAOd,WAAW;gBAClBiC,WAAW,IAAIC,KAAKA,KAAKC,GAAG,KAAKb,oBAAoB;YACvD;YACAT;QACF;QAEA,MAAMuB,0BAA0BnC,qBAC9B,OAAOoC;YACLA,IAAIzB,OAAO,GAAG;gBAAE,GAAGO,WAAW;gBAAEJ,MAAMA;YAAK;YAC3C,MAAMsB,IAAIC,eAAe,CACvBD,IAAIzB,OAAO,CAAC2B,WAAW,CAACC,YAAY,CAACC,IAAI,EACzClB,QAAQT,KAAK,EACbuB,IAAIzB,OAAO,CAAC8B,MAAM,EAClBL,IAAIzB,OAAO,CAAC2B,WAAW,CAACC,YAAY,CAAC/B,OAAO;YAE9C,MAAMkC,sBAAsB,MAAMpC,mBAAmB;gBACnDqC,YAAY;oBAAErB;oBAASR;gBAAK;gBAC5B8B,eAAe7B;gBACf8B,iBAAiB;oBACfC,oBAAoBtC,QAAQuC,mBAAmB;oBAC/CC,uBAAuBxC,QAAQiB,sBAAsB;gBACvD;YACF;YACA,MAAMxB,eAAemC,KAAKM;YAC1B,IAAI,qBAAqBN,KAAK;gBAC5B,OAAOA,IAAIa,eAAe;YAC5B;YACA,OAAO;QACT;QAGF,yFAAyF;QACzF,MAAMC,cAAc;YAClB,GAAGtC,GAAG;YACNuC,MAAMC,UAAU,8DAA8D;QAChF;QAEA,MAAMH,kBAAkB,MAAMd,wBAAwBe;QACtD,MAAMG,kBAAkBJ,iBACpBK,eACDC,IAAI,CAACC,SAAWtD,eAAesD,SAC/BC,OAAOC;QAEV,IAAIL,iBAAiB;YACnB,KAAK,MAAMM,cAAcN,gBAAiB;gBACxC,MAAM,EAAEb,IAAI,EAAEoB,KAAK,EAAE,GAAGpD,SAAS,GAAGmD;gBACpC1C,YAAY4C,GAAG,CAAC;oBACd,GAAGrD,OAAO;oBACVgC;oBACAoB,OAAOE,mBAAmBF;gBAC5B;YACF;QACF;IACF;IAEA,OAAOnD;AACT,EAAE"}

package/dist/better-auth/plugin/{collections → lib/build-collections}/users/hooks/after-logout.d.ts

@@ -1,4 +1,4 @@
-import type { CollectionAfterLogoutHook } from 'payload';
+import type { CollectionAfterLogoutHook } from "payload";
 type AfterLogoutOptions = {
     sessionsCollectionSlug: string;
 };

package/dist/better-auth/plugin/lib/build-collections/users/hooks/after-logout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"after-logout.d.ts","sourceRoot":"","sources":["../../../../../../../src/better-auth/plugin/lib/build-collections/users/hooks/after-logout.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAOzD,KAAK,kBAAkB,GAAG;IACxB,sBAAsB,EAAE,MAAM,CAAC;CAChC,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,SAAS,kBAAkB,KAC1B,yBA4EF,CAAC"}

package/dist/better-auth/plugin/lib/build-collections/users/hooks/after-logout.js

@@ -0,0 +1,74 @@
+import { cookies } from "next/headers";
+import { getPayloadAuth } from "../../../../lib/get-payload-auth";
+export const getAfterLogoutHook = (options)=>{
+    const hook = async ({ req })=>{
+        const cookieStore = await cookies();
+        const payload = await getPayloadAuth(req.payload.config);
+        const securePrefix = "__Secure-";
+        const authContext = await payload.betterAuth.$context;
+        const sessionTokenName = authContext.authCookies.sessionToken.name;
+        const sessionDataName = authContext.authCookies.sessionData.name;
+        const dontRememberTokenName = authContext.authCookies.dontRememberToken.name;
+        try {
+            const sessionCookieValue = cookieStore.get(sessionTokenName)?.value;
+            if (sessionCookieValue) {
+                const payload = req.payload;
+                const [token] = sessionCookieValue.split(".");
+                const { docs: sessions } = await payload.find({
+                    collection: options.sessionsCollectionSlug,
+                    where: {
+                        token: {
+                            equals: token
+                        }
+                    },
+                    limit: 1,
+                    req
+                });
+                const session = sessions.at(0);
+                if (session) {
+                    try {
+                        await payload.delete({
+                            collection: options.sessionsCollectionSlug,
+                            where: {
+                                id: {
+                                    equals: session.id
+                                }
+                            },
+                            req
+                        });
+                    } catch (error) {
+                        console.error("Error deleting session:", error);
+                    }
+                }
+            }
+            const baseMultiSessionName = sessionTokenName + "_multi";
+            const multiSessionCookies = cookieStore.getAll();
+            multiSessionCookies.forEach((cookie)=>{
+                if (cookie.name.startsWith(baseMultiSessionName)) {
+                    cookieStore.delete(cookie.name);
+                }
+                const secureMultiSessionName = securePrefix + baseMultiSessionName;
+                if (cookie.name.startsWith(secureMultiSessionName)) {
+                    cookieStore.delete(cookie.name);
+                }
+            });
+        } catch (error) {
+            console.error("Error afterLogoutHook:", error);
+        }
+        //TODO: this is a hack to delete the admin session cookie
+        // we need to find a better way to do this (BETTER AUTH HARDCODED THIS)
+        cookieStore.delete("admin_session");
+        const cleanSessionTokenName = sessionTokenName.replace(securePrefix, "");
+        const cleanSessionDataName = sessionDataName.replace(securePrefix, "");
+        const cleanDontRememberTokenName = dontRememberTokenName.replace(securePrefix, "");
+        cookieStore.delete(cleanSessionTokenName);
+        cookieStore.delete(`__Secure-${cleanSessionTokenName}`);
+        cookieStore.delete(cleanSessionDataName);
+        cookieStore.delete(`__Secure-${cleanSessionDataName}`);
+        cookieStore.delete(cleanDontRememberTokenName);
+        cookieStore.delete(`__Secure-${cleanDontRememberTokenName}`);
+    };
+    return hook;
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../../src/better-auth/plugin/lib/build-collections/users/hooks/after-logout.ts"],"sourcesContent":["import { cookies } from \"next/headers\";\nimport type { CollectionAfterLogoutHook } from \"payload\";\nimport type { CollectionHookWithBetterAuth } from \"../../../../types\";\nimport { getPayloadAuth } from \"../../../../lib/get-payload-auth\";\n\ntype CollectionAfterLogoutHookWithBetterAuth =\n  CollectionHookWithBetterAuth<CollectionAfterLogoutHook>;\n\ntype AfterLogoutOptions = {\n  sessionsCollectionSlug: string;\n};\n\nexport const getAfterLogoutHook = (\n  options: AfterLogoutOptions\n): CollectionAfterLogoutHook => {\n  const hook: CollectionAfterLogoutHookWithBetterAuth = async ({ req }) => {\n    const cookieStore = await cookies();\n    const payload = await getPayloadAuth(req.payload.config);\n    const securePrefix = \"__Secure-\";\n    const authContext = await payload.betterAuth.$context;\n    const sessionTokenName = authContext.authCookies.sessionToken.name;\n    const sessionDataName = authContext.authCookies.sessionData.name;\n    const dontRememberTokenName =\n      authContext.authCookies.dontRememberToken.name;\n\n    try {\n      const sessionCookieValue = cookieStore.get(sessionTokenName)?.value;\n      if (sessionCookieValue) {\n        const payload = req.payload;\n        const [token] = sessionCookieValue.split(\".\");\n        const { docs: sessions } = await payload.find({\n          collection: options.sessionsCollectionSlug,\n          where: {\n            token: { equals: token },\n          },\n          limit: 1,\n          req,\n        });\n        const session = sessions.at(0);\n        if (session) {\n          try {\n            await payload.delete({\n              collection: options.sessionsCollectionSlug,\n              where: {\n                id: { equals: session.id },\n              },\n              req,\n            });\n          } catch (error) {\n            console.error(\"Error deleting session:\", error);\n          }\n        }\n      }\n\n      const baseMultiSessionName = sessionTokenName + \"_multi\";\n      const multiSessionCookies = cookieStore.getAll();\n      multiSessionCookies.forEach((cookie) => {\n        if (cookie.name.startsWith(baseMultiSessionName)) {\n          cookieStore.delete(cookie.name);\n        }\n        const secureMultiSessionName = securePrefix + baseMultiSessionName;\n        if (cookie.name.startsWith(secureMultiSessionName)) {\n          cookieStore.delete(cookie.name);\n        }\n      });\n    } catch (error) {\n      console.error(\"Error afterLogoutHook:\", error);\n    }\n    //TODO: this is a hack to delete the admin session cookie\n    // we need to find a better way to do this (BETTER AUTH HARDCODED THIS)\n    cookieStore.delete(\"admin_session\");\n\n    const cleanSessionTokenName = sessionTokenName.replace(securePrefix, \"\");\n    const cleanSessionDataName = sessionDataName.replace(securePrefix, \"\");\n    const cleanDontRememberTokenName = dontRememberTokenName.replace(\n      securePrefix,\n      \"\"\n    );\n\n    cookieStore.delete(cleanSessionTokenName);\n    cookieStore.delete(`__Secure-${cleanSessionTokenName}`);\n\n    cookieStore.delete(cleanSessionDataName);\n    cookieStore.delete(`__Secure-${cleanSessionDataName}`);\n\n    cookieStore.delete(cleanDontRememberTokenName);\n    cookieStore.delete(`__Secure-${cleanDontRememberTokenName}`);\n  };\n\n  return hook as CollectionAfterLogoutHook;\n};\n"],"names":["cookies","getPayloadAuth","getAfterLogoutHook","options","hook","req","cookieStore","payload","config","securePrefix","authContext","betterAuth","$context","sessionTokenName","authCookies","sessionToken","name","sessionDataName","sessionData","dontRememberTokenName","dontRememberToken","sessionCookieValue","get","value","token","split","docs","sessions","find","collection","sessionsCollectionSlug","where","equals","limit","session","at","delete","id","error","console","baseMultiSessionName","multiSessionCookies","getAll","forEach","cookie","startsWith","secureMultiSessionName","cleanSessionTokenName","replace","cleanSessionDataName","cleanDontRememberTokenName"],"mappings":"AAAA,SAASA,OAAO,QAAQ,eAAe;AAGvC,SAASC,cAAc,QAAQ,mCAAmC;AASlE,OAAO,MAAMC,qBAAqB,CAChCC;IAEA,MAAMC,OAAgD,OAAO,EAAEC,GAAG,EAAE;QAClE,MAAMC,cAAc,MAAMN;QAC1B,MAAMO,UAAU,MAAMN,eAAeI,IAAIE,OAAO,CAACC,MAAM;QACvD,MAAMC,eAAe;QACrB,MAAMC,cAAc,MAAMH,QAAQI,UAAU,CAACC,QAAQ;QACrD,MAAMC,mBAAmBH,YAAYI,WAAW,CAACC,YAAY,CAACC,IAAI;QAClE,MAAMC,kBAAkBP,YAAYI,WAAW,CAACI,WAAW,CAACF,IAAI;QAChE,MAAMG,wBACJT,YAAYI,WAAW,CAACM,iBAAiB,CAACJ,IAAI;QAEhD,IAAI;YACF,MAAMK,qBAAqBf,YAAYgB,GAAG,CAACT,mBAAmBU;YAC9D,IAAIF,oBAAoB;gBACtB,MAAMd,UAAUF,IAAIE,OAAO;gBAC3B,MAAM,CAACiB,MAAM,GAAGH,mBAAmBI,KAAK,CAAC;gBACzC,MAAM,EAAEC,MAAMC,QAAQ,EAAE,GAAG,MAAMpB,QAAQqB,IAAI,CAAC;oBAC5CC,YAAY1B,QAAQ2B,sBAAsB;oBAC1CC,OAAO;wBACLP,OAAO;4BAAEQ,QAAQR;wBAAM;oBACzB;oBACAS,OAAO;oBACP5B;gBACF;gBACA,MAAM6B,UAAUP,SAASQ,EAAE,CAAC;gBAC5B,IAAID,SAAS;oBACX,IAAI;wBACF,MAAM3B,QAAQ6B,MAAM,CAAC;4BACnBP,YAAY1B,QAAQ2B,sBAAsB;4BAC1CC,OAAO;gCACLM,IAAI;oCAAEL,QAAQE,QAAQG,EAAE;gCAAC;4BAC3B;4BACAhC;wBACF;oBACF,EAAE,OAAOiC,OAAO;wBACdC,QAAQD,KAAK,CAAC,2BAA2BA;oBAC3C;gBACF;YACF;YAEA,MAAME,uBAAuB3B,mBAAmB;YAChD,MAAM4B,sBAAsBnC,YAAYoC,MAAM;YAC9CD,oBAAoBE,OAAO,CAAC,CAACC;gBAC3B,IAAIA,OAAO5B,IAAI,CAAC6B,UAAU,CAACL,uBAAuB;oBAChDlC,YAAY8B,MAAM,CAACQ,OAAO5B,IAAI;gBAChC;gBACA,MAAM8B,yBAAyBrC,eAAe+B;gBAC9C,IAAII,OAAO5B,IAAI,CAAC6B,UAAU,CAACC,yBAAyB;oBAClDxC,YAAY8B,MAAM,CAACQ,OAAO5B,IAAI;gBAChC;YACF;QACF,EAAE,OAAOsB,OAAO;YACdC,QAAQD,KAAK,CAAC,0BAA0BA;QAC1C;QACA,yDAAyD;QACzD,uEAAuE;QACvEhC,YAAY8B,MAAM,CAAC;QAEnB,MAAMW,wBAAwBlC,iBAAiBmC,OAAO,CAACvC,cAAc;QACrE,MAAMwC,uBAAuBhC,gBAAgB+B,OAAO,CAACvC,cAAc;QACnE,MAAMyC,6BAA6B/B,sBAAsB6B,OAAO,CAC9DvC,cACA;QAGFH,YAAY8B,MAAM,CAACW;QACnBzC,YAAY8B,MAAM,CAAC,CAAC,SAAS,EAAEW,uBAAuB;QAEtDzC,YAAY8B,MAAM,CAACa;QACnB3C,YAAY8B,MAAM,CAAC,CAAC,SAAS,EAAEa,sBAAsB;QAErD3C,YAAY8B,MAAM,CAACc;QACnB5C,YAAY8B,MAAM,CAAC,CAAC,SAAS,EAAEc,4BAA4B;IAC7D;IAEA,OAAO9C;AACT,EAAE"}