@luochuanyuewu/payload-auth 1.8.0

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

@@ -0,0 +1,68 @@
+import { status as httpStatus } from "http-status";
+import { addDataAndFileToRequest } from "payload";
+import { adminEndpoints, baseSlugs } from "../../../../constants";
+import { generateAdminInviteUrl } from "../../../../payload/utils/generate-admin-invite-url";
+export const getGenerateInviteUrlEndpoint = ({ roles, pluginOptions })=>{
+    const endpoint = {
+        path: adminEndpoints.generateInviteUrl,
+        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 ?? baseSlugs.adminInvitations,
+                    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/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./generate-invite-url";
+export * from "./refresh-token";
+export * from "./send-invite-url";
+export * from "./set-admin-role";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/better-auth/plugin/lib/build-collections/users/endpoints/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}

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

@@ -0,0 +1,6 @@
+export * from "./generate-invite-url";
+export * from "./refresh-token";
+export * from "./send-invite-url";
+export * from "./set-admin-role";
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9iZXR0ZXItYXV0aC9wbHVnaW4vbGliL2J1aWxkLWNvbGxlY3Rpb25zL3VzZXJzL2VuZHBvaW50cy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9nZW5lcmF0ZS1pbnZpdGUtdXJsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9yZWZyZXNoLXRva2VuXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zZW5kLWludml0ZS11cmxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NldC1hZG1pbi1yb2xlXCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0I7QUFDdEMsY0FBYyxrQkFBa0I7QUFDaEMsY0FBYyxvQkFBb0I7QUFDbEMsY0FBYyxtQkFBbUIifQ==

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":"AAEA,OAAO,EACL,KAAK,QAAQ,EAId,MAAM,SAAS,CAAC;AAKjB,eAAO,MAAM,uBAAuB,GAAI,UAAU,MAAM,KAAG,QA+H1D,CAAC"}

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

@@ -0,0 +1,114 @@
+import { setCookieCache } from "better-auth/cookies";
+import { getFieldsToSign, refreshOperation } from "payload";
+import { adminEndpoints } from "../../../../constants";
+import { getSignedCookie } from "../../../../helpers/get-signed-cookie";
+import { getPayloadAuth } from "../../../get-payload-auth";
+export const getRefreshTokenEndpoint = (userSlug)=>{
+    const endpoint = {
+        path: adminEndpoints.refreshToken,
+        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}=`);
+            const dontRememberTokenName = authContext.authCookies.dontRememberToken.name;
+            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;
+                }
+            };
+            const dontRememberMe = await getSignedCookie(cookieHeader, dontRememberTokenName, authContext.secret);
+            await setCookieCache(ctx, {
+                session: res.session,
+                user: cookieCacheFields
+            }, !!dontRememberMe);
+            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 type { GenericEndpointContext } from \"better-auth\";\nimport { setCookieCache } from \"better-auth/cookies\";\nimport {\n  type Endpoint,\n  getFieldsToSign,\n  refreshOperation,\n  TypedUser\n} from \"payload\";\nimport { adminEndpoints } from \"@/better-auth/plugin/constants\";\nimport { getSignedCookie } from \"@/better-auth/plugin/helpers/get-signed-cookie\";\nimport { getPayloadAuth } from \"@/better-auth/plugin/lib/get-payload-auth\";\n\nexport const getRefreshTokenEndpoint = (userSlug: string): Endpoint => {\n  const endpoint: Endpoint = {\n    path: adminEndpoints.refreshToken,\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      const dontRememberTokenName =\n        authContext.authCookies.dontRememberToken.name;\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 TypedUser\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      const dontRememberMe = await getSignedCookie(\n        cookieHeader,\n        dontRememberTokenName,\n        authContext.secret\n      );\n\n      await setCookieCache(\n        ctx,\n        {\n          session: res.session,\n          user: cookieCacheFields as any\n        },\n        !!dontRememberMe\n      );\n\n      return response;\n    }\n  };\n\n  return endpoint;\n};\n"],"names":["setCookieCache","getFieldsToSign","refreshOperation","adminEndpoints","getSignedCookie","getPayloadAuth","getRefreshTokenEndpoint","userSlug","endpoint","path","refreshToken","method","handler","req","payload","config","authContext","betterAuth","$context","userCollection","collections","Response","JSON","stringify","message","status","sessionTokenName","authCookies","sessionToken","name","cookieHeader","headers","get","hasSessionToken","includes","dontRememberTokenName","dontRememberToken","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","dontRememberMe","secret"],"mappings":"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"}

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

@@ -0,0 +1,4 @@
+import { Endpoint } from "payload";
+import type { PayloadAuthOptions } from "@/better-auth/plugin/types";
+export declare const getSendInviteUrlEndpoint: (pluginOptions: PayloadAuthOptions) => 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":"AACA,OAAO,EAEL,QAAQ,EAGT,MAAM,SAAS,CAAC;AAGjB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAOrE,eAAO,MAAM,wBAAwB,GACnC,eAAe,kBAAkB,KAChC,QA4DF,CAAC"}

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

@@ -0,0 +1,64 @@
+import { status as httpStatus } from "http-status";
+import { addDataAndFileToRequest, headersWithCors, killTransaction } from "payload";
+import { z } from "zod";
+import { adminEndpoints } from "../../../../constants";
+const requestSchema = z.object({
+    email: z.email(),
+    link: z.string()
+});
+export const getSendInviteUrlEndpoint = (pluginOptions)=>{
+    const endpoint = {
+        path: adminEndpoints.sendInvite,
+        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 sendInviteEmailFn = pluginOptions.adminInvitations?.sendInviteEmail;
+            if (!sendInviteEmailFn) {
+                req.payload.logger.error("Send admin invite email function not configured, please add the function to the betterAuthPlugin options.");
+                return Response.json({
+                    message: "Send invite email function not found"
+                }, {
+                    status: httpStatus.INTERNAL_SERVER_ERROR
+                });
+            }
+            try {
+                const res = await sendInviteEmailFn({
+                    payload: req.payload,
+                    email: body.data.email,
+                    url: body.data.link
+                });
+                if (!res.success) {
+                    return Response.json({
+                        message: res.message
+                    }, {
+                        status: httpStatus.INTERNAL_SERVER_ERROR
+                    });
+                }
+                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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9iZXR0ZXItYXV0aC9wbHVnaW4vbGliL2J1aWxkLWNvbGxlY3Rpb25zL3VzZXJzL2VuZHBvaW50cy9zZW5kLWludml0ZS11cmwudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgc3RhdHVzIGFzIGh0dHBTdGF0dXMgfSBmcm9tIFwiaHR0cC1zdGF0dXNcIjtcbmltcG9ydCB7XG4gIGFkZERhdGFBbmRGaWxlVG9SZXF1ZXN0LFxuICBFbmRwb2ludCxcbiAgaGVhZGVyc1dpdGhDb3JzLFxuICBraWxsVHJhbnNhY3Rpb25cbn0gZnJvbSBcInBheWxvYWRcIjtcbmltcG9ydCB7IHogfSBmcm9tIFwiem9kXCI7XG5pbXBvcnQgeyBhZG1pbkVuZHBvaW50cyB9IGZyb20gXCJAL2JldHRlci1hdXRoL3BsdWdpbi9jb25zdGFudHNcIjtcbmltcG9ydCB0eXBlIHsgUGF5bG9hZEF1dGhPcHRpb25zIH0gZnJvbSBcIkAvYmV0dGVyLWF1dGgvcGx1Z2luL3R5cGVzXCI7XG5cbmNvbnN0IHJlcXVlc3RTY2hlbWEgPSB6Lm9iamVjdCh7XG4gIGVtYWlsOiB6LmVtYWlsKCksXG4gIGxpbms6IHouc3RyaW5nKClcbn0pO1xuXG5leHBvcnQgY29uc3QgZ2V0U2VuZEludml0ZVVybEVuZHBvaW50ID0gKFxuICBwbHVnaW5PcHRpb25zOiBQYXlsb2FkQXV0aE9wdGlvbnNcbik6IEVuZHBvaW50ID0+IHtcbiAgY29uc3QgZW5kcG9pbnQ6IEVuZHBvaW50ID0ge1xuICAgIHBhdGg6IGFkbWluRW5kcG9pbnRzLnNlbmRJbnZpdGUsXG4gICAgbWV0aG9kOiBcInBvc3RcIixcbiAgICBoYW5kbGVyOiBhc3luYyAocmVxKSA9PiB7XG4gICAgICBhd2FpdCBhZGREYXRhQW5kRmlsZVRvUmVxdWVzdChyZXEpO1xuICAgICAgY29uc3QgeyB0IH0gPSByZXE7XG4gICAgICBjb25zdCBib2R5ID0gcmVxdWVzdFNjaGVtYS5zYWZlUGFyc2UocmVxLmRhdGEpO1xuICAgICAgaWYgKCFib2R5LnN1Y2Nlc3MpIHtcbiAgICAgICAgcmV0dXJuIFJlc3BvbnNlLmpzb24oXG4gICAgICAgICAgeyBtZXNzYWdlOiBib2R5LmVycm9yLm1lc3NhZ2UgfSxcbiAgICAgICAgICB7IHN0YXR1czogaHR0cFN0YXR1cy5CQURfUkVRVUVTVCB9XG4gICAgICAgICk7XG4gICAgICB9XG5cbiAgICAgIGNvbnN0IHNlbmRJbnZpdGVFbWFpbEZuID0gcGx1Z2luT3B0aW9ucy5hZG1pbkludml0YXRpb25zPy5zZW5kSW52aXRlRW1haWw7XG5cbiAgICAgIGlmICghc2VuZEludml0ZUVtYWlsRm4pIHtcbiAgICAgICAgcmVxLnBheWxvYWQubG9nZ2VyLmVycm9yKFxuICAgICAgICAgIFwiU2VuZCBhZG1pbiBpbnZpdGUgZW1haWwgZnVuY3Rpb24gbm90IGNvbmZpZ3VyZWQsIHBsZWFzZSBhZGQgdGhlIGZ1bmN0aW9uIHRvIHRoZSBiZXR0ZXJBdXRoUGx1Z2luIG9wdGlvbnMuXCJcbiAgICAgICAgKTtcbiAgICAgICAgcmV0dXJuIFJlc3BvbnNlLmpzb24oXG4gICAgICAgICAgeyBtZXNzYWdlOiBcIlNlbmQgaW52aXRlIGVtYWlsIGZ1bmN0aW9uIG5vdCBmb3VuZFwiIH0sXG4gICAgICAgICAgeyBzdGF0dXM6IGh0dHBTdGF0dXMuSU5URVJOQUxfU0VSVkVSX0VSUk9SIH1cbiAgICAgICAgKTtcbiAgICAgIH1cblxuICAgICAgdHJ5IHtcbiAgICAgICAgY29uc3QgcmVzID0gYXdhaXQgc2VuZEludml0ZUVtYWlsRm4oe1xuICAgICAgICAgIHBheWxvYWQ6IHJlcS5wYXlsb2FkLFxuICAgICAgICAgIGVtYWlsOiBib2R5LmRhdGEuZW1haWwsXG4gICAgICAgICAgdXJsOiBib2R5LmRhdGEubGlua1xuICAgICAgICB9KTtcblxuICAgICAgICBpZiAoIXJlcy5zdWNjZXNzKSB7XG4gICAgICAgICAgcmV0dXJuIFJlc3BvbnNlLmpzb24oXG4gICAgICAgICAgICB7IG1lc3NhZ2U6IHJlcy5tZXNzYWdlIH0sXG4gICAgICAgICAgICB7IHN0YXR1czogaHR0cFN0YXR1cy5JTlRFUk5BTF9TRVJWRVJfRVJST1IgfVxuICAgICAgICAgICk7XG4gICAgICAgIH1cblxuICAgICAgICByZXR1cm4gUmVzcG9uc2UuanNvbihcbiAgICAgICAgICB7XG4gICAgICAgICAgICBtZXNzYWdlOiB0KFwiZ2VuZXJhbDpzdWNjZXNzXCIpXG4gICAgICAgICAgfSxcbiAgICAgICAgICB7XG4gICAgICAgICAgICBoZWFkZXJzOiBoZWFkZXJzV2l0aENvcnMoe1xuICAgICAgICAgICAgICBoZWFkZXJzOiBuZXcgSGVhZGVycygpLFxuICAgICAgICAgICAgICByZXFcbiAgICAgICAgICAgIH0pLFxuICAgICAgICAgICAgc3RhdHVzOiBodHRwU3RhdHVzLk9LXG4gICAgICAgICAgfVxuICAgICAgICApO1xuICAgICAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICAgICAgYXdhaXQga2lsbFRyYW5zYWN0aW9uKHJlcSk7XG4gICAgICAgIHRocm93IGVycm9yO1xuICAgICAgfVxuICAgIH1cbiAgfTtcbiAgcmV0dXJuIGVuZHBvaW50O1xufTtcbiJdLCJuYW1lcyI6WyJzdGF0dXMiLCJodHRwU3RhdHVzIiwiYWRkRGF0YUFuZEZpbGVUb1JlcXVlc3QiLCJoZWFkZXJzV2l0aENvcnMiLCJraWxsVHJhbnNhY3Rpb24iLCJ6IiwiYWRtaW5FbmRwb2ludHMiLCJyZXF1ZXN0U2NoZW1hIiwib2JqZWN0IiwiZW1haWwiLCJsaW5rIiwic3RyaW5nIiwiZ2V0U2VuZEludml0ZVVybEVuZHBvaW50IiwicGx1Z2luT3B0aW9ucyIsImVuZHBvaW50IiwicGF0aCIsInNlbmRJbnZpdGUiLCJtZXRob2QiLCJoYW5kbGVyIiwicmVxIiwidCIsImJvZHkiLCJzYWZlUGFyc2UiLCJkYXRhIiwic3VjY2VzcyIsIlJlc3BvbnNlIiwianNvbiIsIm1lc3NhZ2UiLCJlcnJvciIsIkJBRF9SRVFVRVNUIiwic2VuZEludml0ZUVtYWlsRm4iLCJhZG1pbkludml0YXRpb25zIiwic2VuZEludml0ZUVtYWlsIiwicGF5bG9hZCIsImxvZ2dlciIsIklOVEVSTkFMX1NFUlZFUl9FUlJPUiIsInJlcyIsInVybCIsImhlYWRlcnMiLCJIZWFkZXJzIiwiT0siXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLFVBQVVDLFVBQVUsUUFBUSxjQUFjO0FBQ25ELFNBQ0VDLHVCQUF1QixFQUV2QkMsZUFBZSxFQUNmQyxlQUFlLFFBQ1YsVUFBVTtBQUNqQixTQUFTQyxDQUFDLFFBQVEsTUFBTTtBQUN4QixTQUFTQyxjQUFjLFFBQVEsd0JBQWlDO0FBR2hFLE1BQU1DLGdCQUFnQkYsRUFBRUcsTUFBTSxDQUFDO0lBQzdCQyxPQUFPSixFQUFFSSxLQUFLO0lBQ2RDLE1BQU1MLEVBQUVNLE1BQU07QUFDaEI7QUFFQSxPQUFPLE1BQU1DLDJCQUEyQixDQUN0Q0M7SUFFQSxNQUFNQyxXQUFxQjtRQUN6QkMsTUFBTVQsZUFBZVUsVUFBVTtRQUMvQkMsUUFBUTtRQUNSQyxTQUFTLE9BQU9DO1lBQ2QsTUFBTWpCLHdCQUF3QmlCO1lBQzlCLE1BQU0sRUFBRUMsQ0FBQyxFQUFFLEdBQUdEO1lBQ2QsTUFBTUUsT0FBT2QsY0FBY2UsU0FBUyxDQUFDSCxJQUFJSSxJQUFJO1lBQzdDLElBQUksQ0FBQ0YsS0FBS0csT0FBTyxFQUFFO2dCQUNqQixPQUFPQyxTQUFTQyxJQUFJLENBQ2xCO29CQUFFQyxTQUFTTixLQUFLTyxLQUFLLENBQUNELE9BQU87Z0JBQUMsR0FDOUI7b0JBQUUzQixRQUFRQyxXQUFXNEIsV0FBVztnQkFBQztZQUVyQztZQUVBLE1BQU1DLG9CQUFvQmpCLGNBQWNrQixnQkFBZ0IsRUFBRUM7WUFFMUQsSUFBSSxDQUFDRixtQkFBbUI7Z0JBQ3RCWCxJQUFJYyxPQUFPLENBQUNDLE1BQU0sQ0FBQ04sS0FBSyxDQUN0QjtnQkFFRixPQUFPSCxTQUFTQyxJQUFJLENBQ2xCO29CQUFFQyxTQUFTO2dCQUF1QyxHQUNsRDtvQkFBRTNCLFFBQVFDLFdBQVdrQyxxQkFBcUI7Z0JBQUM7WUFFL0M7WUFFQSxJQUFJO2dCQUNGLE1BQU1DLE1BQU0sTUFBTU4sa0JBQWtCO29CQUNsQ0csU0FBU2QsSUFBSWMsT0FBTztvQkFDcEJ4QixPQUFPWSxLQUFLRSxJQUFJLENBQUNkLEtBQUs7b0JBQ3RCNEIsS0FBS2hCLEtBQUtFLElBQUksQ0FBQ2IsSUFBSTtnQkFDckI7Z0JBRUEsSUFBSSxDQUFDMEIsSUFBSVosT0FBTyxFQUFFO29CQUNoQixPQUFPQyxTQUFTQyxJQUFJLENBQ2xCO3dCQUFFQyxTQUFTUyxJQUFJVCxPQUFPO29CQUFDLEdBQ3ZCO3dCQUFFM0IsUUFBUUMsV0FBV2tDLHFCQUFxQjtvQkFBQztnQkFFL0M7Z0JBRUEsT0FBT1YsU0FBU0MsSUFBSSxDQUNsQjtvQkFDRUMsU0FBU1AsRUFBRTtnQkFDYixHQUNBO29CQUNFa0IsU0FBU25DLGdCQUFnQjt3QkFDdkJtQyxTQUFTLElBQUlDO3dCQUNicEI7b0JBQ0Y7b0JBQ0FuQixRQUFRQyxXQUFXdUMsRUFBRTtnQkFDdkI7WUFFSixFQUFFLE9BQU9aLE9BQU87Z0JBQ2QsTUFBTXhCLGdCQUFnQmU7Z0JBQ3RCLE1BQU1TO1lBQ1I7UUFDRjtJQUNGO0lBQ0EsT0FBT2Q7QUFDVCxFQUFFIn0=

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 { PayloadAuthOptions } from "../../../../types";
+export declare const getSetAdminRoleEndpoint: (pluginOptions: PayloadAuthOptions, 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":"AACA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAQvD,eAAO,MAAM,uBAAuB,GAClC,eAAe,kBAAkB,EACjC,UAAU,MAAM,KACf,QA0EF,CAAC"}

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

@@ -0,0 +1,90 @@
+import { status as httpStatus } from "http-status";
+import { z } from "zod";
+import { adminEndpoints, baseSlugs } from "../../../../constants";
+import { getPayloadAuth } from "../../../get-payload-auth";
+const setAdminRoleSchema = z.object({
+    token: z.string().optional(),
+    redirect: z.string().optional()
+});
+export const getSetAdminRoleEndpoint = (pluginOptions, userSlug)=>{
+    const endpoint = {
+        path: adminEndpoints.setAdminRole,
+        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 ?? baseSlugs.adminInvitations,
+                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;
+            try {
+                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 ?? baseSlugs.adminInvitations,
+                    where: {
+                        token: {
+                            equals: token
+                        }
+                    }
+                });
+                const response = new Response(null, {
+                    status: 307,
+                    headers: {
+                        Location: redirect ?? config.routes.admin
+                    }
+                });
+                return response;
+            } catch (error) {
+                return Response.json({
+                    message: "Error updating user role"
+                }, {
+                    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/hooks/after-login.d.ts

@@ -0,0 +1,7 @@
+import { CollectionAfterLoginHook } from "payload";
+/**
+ * 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 declare function getAfterLoginHook(): CollectionAfterLoginHook;
+//# sourceMappingURL=after-login.d.ts.map

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;AAMnD;;;GAGG;AACH,wBAAgB,iBAAiB,IA+EhB,wBAAwB,CACxC"}

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

@@ -0,0 +1,80 @@
+import { generateId } from "better-auth";
+import { createAuthMiddleware } from "better-auth/api";
+import { setSessionCookie } from "better-auth/cookies";
+import { parseSetCookie } from "next/dist/compiled/@edge-runtime/cookies";
+import { cookies } from "next/headers";
+import { baModelKey } from "../../../../constants";
+import { getCollectionByModelKey } from "../../../../helpers/get-collection";
+import { getIp } from "../../../../helpers/get-ip";
+import { prepareSessionData } from "../../../../helpers/prepare-session-data";
+import { getPayloadAuth } from "../../../get-payload-auth";
+/**
+ * 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 function getAfterLoginHook() {
+    const hook = async ({ req, user })=>{
+        const config = req.payload.config;
+        const payload = await getPayloadAuth(config);
+        const collections = req.payload.collections;
+        const userCollection = getCollectionByModelKey(collections, baModelKey.user);
+        const sessionCollection = getCollectionByModelKey(collections, baModelKey.session);
+        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: sessionCollection.slug,
+            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,
+            depth: 0
+        });
+        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({
+                sessionData: {
+                    session,
+                    user
+                },
+                usersCollection: userCollection,
+                sessionsCollection: sessionCollection
+            });
+            if (filteredSessionData) {
+                await setSessionCookie(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 { setSessionCookie } 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 { baModelKey } from \"@/better-auth/plugin/constants\";\nimport { getCollectionByModelKey } from \"@/better-auth/plugin/helpers/get-collection\";\nimport { getIp } from \"@/better-auth/plugin/helpers/get-ip\";\nimport { prepareSessionData } from \"@/better-auth/plugin/helpers/prepare-session-data\";\nimport { getPayloadAuth } from \"@/better-auth/plugin/lib/get-payload-auth\";\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 function getAfterLoginHook() {\n  const hook: CollectionAfterLoginHook = async ({ req, user }) => {\n    const config = req.payload.config;\n    const payload = await getPayloadAuth(config);\n    const collections = req.payload.collections;\n    const userCollection = getCollectionByModelKey(\n      collections,\n      baModelKey.user\n    );\n    const sessionCollection = getCollectionByModelKey(\n      collections,\n      baModelKey.session\n    );\n    const cookieStore = await cookies();\n    const authContext = await payload.betterAuth.$context;\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: sessionCollection.slug,\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      depth: 0\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          sessionData: { session, user },\n          usersCollection: userCollection,\n          sessionsCollection: sessionCollection\n        });\n        if (filteredSessionData) {\n          await setSessionCookie(ctx, filteredSessionData);\n        }\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","setSessionCookie","parseSetCookie","cookies","baModelKey","getCollectionByModelKey","getIp","prepareSessionData","getPayloadAuth","getAfterLoginHook","hook","req","user","config","payload","collections","userCollection","sessionCollection","session","cookieStore","authContext","betterAuth","$context","sessionExpiration","options","expiresIn","create","collection","slug","data","ipAddress","headers","userAgent","get","id","token","expiresAt","Date","now","depth","betterAuthHandleRequest","ctx","context","setSignedCookie","authCookies","sessionToken","name","secret","filteredSessionData","sessionData","usersCollection","sessionsCollection","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,gBAAgB,QAAQ,sBAAsB;AACvD,SACEC,cAAc,QAET,2CAA2C;AAClD,SAASC,OAAO,QAAQ,eAAe;AAEvC,SAASC,UAAU,QAAQ,wBAAiC;AAC5D,SAASC,uBAAuB,QAAQ,qCAA8C;AACtF,SAASC,KAAK,QAAQ,6BAAsC;AAC5D,SAASC,kBAAkB,QAAQ,2CAAoD;AACvF,SAASC,cAAc,QAAQ,4BAA4C;AAC3E;;;CAGC,GACD,OAAO,SAASC;IACd,MAAMC,OAAiC,OAAO,EAAEC,GAAG,EAAEC,IAAI,EAAE;QACzD,MAAMC,SAASF,IAAIG,OAAO,CAACD,MAAM;QACjC,MAAMC,UAAU,MAAMN,eAAeK;QACrC,MAAME,cAAcJ,IAAIG,OAAO,CAACC,WAAW;QAC3C,MAAMC,iBAAiBX,wBACrBU,aACAX,WAAWQ,IAAI;QAEjB,MAAMK,oBAAoBZ,wBACxBU,aACAX,WAAWc,OAAO;QAEpB,MAAMC,cAAc,MAAMhB;QAC1B,MAAMiB,cAAc,MAAMN,QAAQO,UAAU,CAACC,QAAQ;QACrD,MAAMC,oBACJT,QAAQO,UAAU,CAACG,OAAO,CAACN,OAAO,EAAEO,aAAa,KAAK,KAAK,KAAK,GAAG,SAAS;QAC9E,0GAA0G;QAC1G,MAAMP,UAAW,MAAMJ,QAAQY,MAAM,CAAC;YACpCC,YAAYV,kBAAkBW,IAAI;YAClCC,MAAM;gBACJC,WAAWxB,MAAMK,IAAIoB,OAAO,EAAEjB,QAAQO,UAAU,CAACG,OAAO,KAAK;gBAC7DQ,WAAWrB,IAAIoB,OAAO,EAAEE,IAAI,iBAAiB;gBAC7CrB,MAAMA,KAAKsB,EAAE;gBACbC,OAAOpC,WAAW;gBAClBqC,WAAW,IAAIC,KAAKA,KAAKC,GAAG,KAAKf,oBAAoB;YACvD;YACAZ;YACA4B,OAAO;QACT;QAEA,MAAMC,0BAA0BxC,qBAC9B,OAAOyC;YACLA,IAAIC,OAAO,GAAG;gBAAE,GAAGtB,WAAW;gBAAER,MAAMA;YAAK;YAC3C,MAAM6B,IAAIE,eAAe,CACvBF,IAAIC,OAAO,CAACE,WAAW,CAACC,YAAY,CAACC,IAAI,EACzC5B,QAAQiB,KAAK,EACbM,IAAIC,OAAO,CAACK,MAAM,EAClBN,IAAIC,OAAO,CAACE,WAAW,CAACC,YAAY,CAACrB,OAAO;YAE9C,MAAMwB,sBAAsB,MAAMzC,mBAAmB;gBACnD0C,aAAa;oBAAE/B;oBAASN;gBAAK;gBAC7BsC,iBAAiBlC;gBACjBmC,oBAAoBlC;YACtB;YACA,IAAI+B,qBAAqB;gBACvB,MAAM/C,iBAAiBwC,KAAKO;YAC9B;YACA,IAAI,qBAAqBP,KAAK;gBAC5B,OAAOA,IAAIW,eAAe;YAC5B;YACA,OAAO;QACT;QAGF,yFAAyF;QACzF,MAAMC,cAAc;YAClB,GAAG1C,GAAG;YACN2C,MAAMC,UAAU,8DAA8D;QAChF;QAEA,MAAMH,kBAAkB,MAAMZ,wBAAwBa;QACtD,MAAMG,kBAAkBJ,iBACpBK,eACDC,IAAI,CAACC,SAAWzD,eAAeyD,SAC/BC,OAAOC;QAEV,IAAIL,iBAAiB;YACnB,KAAK,MAAMM,cAAcN,gBAAiB;gBACxC,MAAM,EAAEV,IAAI,EAAEiB,KAAK,EAAE,GAAGvC,SAAS,GAAGsC;gBACpC3C,YAAY6C,GAAG,CAAC;oBACd,GAAGxC,OAAO;oBACVsB;oBACAiB,OAAOE,mBAAmBF;gBAC5B;YACF;QACF;IACF;IAEA,OAAOrD;AACT"}

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

@@ -0,0 +1,3 @@
+import type { CollectionAfterLogoutHook } from "payload";
+export declare function getAfterLogoutHook(): CollectionAfterLogoutHook;
+//# sourceMappingURL=after-logout.d.ts.map

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,EAAkB,MAAM,SAAS,CAAC;AAKzE,wBAAgB,kBAAkB,8BAoDjC"}