@luochuanyuewu/payload-auth 1.8.0

package/dist/better-auth/plugin/lib/sanitize-better-auth-options/utils/password.js

@@ -0,0 +1,62 @@
+import crypto from "crypto";
+/**
+ * Mimics Payload's internal password hashing using pbkdf2
+ *
+ * This generates a hash compatible with Payload's internal auth system
+ * so that passwords set via better-auth can be used with Payload admin panel
+ */ function pbkdf2Promisified(password, salt) {
+    return new Promise((resolve, reject)=>crypto.pbkdf2(password, salt, 25000, 512, "sha256", (err, hashRaw)=>err ? reject(err) : resolve(hashRaw)));
+}
+/**
+ * Generates random bytes for the salt
+ */ function randomBytes() {
+    return new Promise((resolve, reject)=>crypto.randomBytes(32, (err, saltBuffer)=>err ? reject(err) : resolve(saltBuffer)));
+}
+/**
+ * Custom implementation of password hashing that matches Payload's format
+ *
+ * Instead of using better-auth's scrypt, this uses pbkdf2 with the same
+ * parameters as Payload CMS
+ *
+ * @param password The password to hash
+ * @returns A string in the format {salt}:{hash}
+ */ export const hashPassword = async (password)=>{
+    const saltBuffer = await randomBytes();
+    const salt = saltBuffer.toString("hex");
+    const hashRaw = await pbkdf2Promisified(password, salt);
+    const hash = hashRaw.toString("hex");
+    return `${salt}:${hash}`;
+};
+/**
+ * Verifies a password against a stored hash
+ *
+ * This function is flexible and can handle:
+ * 1. A combined string in format {salt}:{hash} (for account passwords)
+ * 2. When salt and hash need to be combined from user records
+ *
+ * @param params Object containing the hash and password
+ * @returns Boolean indicating if the password matches
+ */ export const verifyPassword = async ({ hash, password, salt })=>{
+    let saltValue;
+    let storedHash;
+    // If salt is provided separately (from user record), use it with the hash
+    if (salt) {
+        saltValue = salt;
+        storedHash = hash;
+    } else {
+        // Otherwise, split the combined format (from account.password)
+        const parts = hash.split(":");
+        if (parts.length !== 2) {
+            return false;
+        }
+        [saltValue, storedHash] = parts;
+    }
+    if (!saltValue || !storedHash) {
+        return false;
+    }
+    const hashRaw = await pbkdf2Promisified(password, saltValue);
+    const computedHash = hashRaw.toString("hex");
+    return storedHash === computedHash;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/lib/sanitize-better-auth-options/utils/require-admin-invite-for-sign-up-middleware.d.ts

@@ -0,0 +1,10 @@
+import type { SanitizedBetterAuthOptions } from "@/better-auth/plugin/types";
+import { PayloadAuthOptions } from "@/better-auth/types";
+/**
+ * Mofies options object and adds a middleware to check for admin invite for sign up
+ */
+export declare const requireAdminInviteForSignUpMiddleware: ({ options, pluginOptions }: {
+    options: SanitizedBetterAuthOptions;
+    pluginOptions: PayloadAuthOptions;
+}) => Promise<void>;
+//# sourceMappingURL=require-admin-invite-for-sign-up-middleware.d.ts.map

package/dist/better-auth/plugin/lib/sanitize-better-auth-options/utils/require-admin-invite-for-sign-up-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-admin-invite-for-sign-up-middleware.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/lib/sanitize-better-auth-options/utils/require-admin-invite-for-sign-up-middleware.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAC;AAC7E,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAQzD;;GAEG;AACH,eAAO,MAAM,qCAAqC,GAAU,4BAGzD;IACD,OAAO,EAAE,0BAA0B,CAAC;IACpC,aAAa,EAAE,kBAAkB,CAAC;CACnC,kBAiCA,CAAC"}

package/dist/better-auth/plugin/lib/sanitize-better-auth-options/utils/require-admin-invite-for-sign-up-middleware.js

@@ -0,0 +1,42 @@
+import { APIError, createAuthMiddleware } from "better-auth/api";
+import { z } from "zod";
+import { baseSlugs } from "../../../constants";
+const throwUnauthorizedError = ()=>{
+    throw new APIError("UNAUTHORIZED", {
+        message: "signup disabled" // mimic: https://github.com/better-auth/better-auth/blob/171fab5273cf38f46cf207b0d99c8ccdda64c2fb/packages/better-auth/src/oauth2/link-account.ts#L108
+    });
+};
+/**
+ * Mofies options object and adds a middleware to check for admin invite for sign up
+ */ export const requireAdminInviteForSignUpMiddleware = async ({ options, pluginOptions })=>{
+    options.hooks = options.hooks || {};
+    const originalBefore = options.hooks.before;
+    options.hooks.before = createAuthMiddleware(async (ctx)=>{
+        if (ctx.path !== "/sign-up/email" && // not an email sign-up request
+        !(ctx.path === "/sign-in/social" && ctx.body?.requestSignUp // not a social sign-in request with sign-up intent
+        )) return;
+        const adminInviteToken = ctx?.query?.adminInviteToken ?? ctx.body.adminInviteToken;
+        if (!!pluginOptions.requireAdminInviteForSignUp && !z.string().uuid().safeParse(adminInviteToken).success) {
+            throwUnauthorizedError();
+            return;
+        }
+        const query = {
+            field: "token",
+            value: adminInviteToken,
+            operator: "eq"
+        };
+        const isValidAdminInvitation = await ctx.context.adapter.count({
+            model: pluginOptions.adminInvitations?.slug ?? baseSlugs.adminInvitations,
+            where: [
+                query
+            ]
+        });
+        if (isValidAdminInvitation) {
+            if (originalBefore) return originalBefore(ctx);
+            return ctx;
+        }
+        throwUnauthorizedError();
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/lib/sanitize-better-auth-options/utils/use-admin-invite-after-email-sign-up-middleware.d.ts

@@ -0,0 +1,10 @@
+import type { SanitizedBetterAuthOptions } from "@/better-auth/plugin/types";
+/**
+ * Modifies options object and adds a middleware to check for admin invite for sign up
+ */
+export declare const useAdminInviteAfterEmailSignUpMiddleware: ({ options, adminInvitationCollectionSlug, userCollectionSlug }: {
+    options: SanitizedBetterAuthOptions;
+    adminInvitationCollectionSlug: string;
+    userCollectionSlug: string;
+}) => Promise<void>;
+//# sourceMappingURL=use-admin-invite-after-email-sign-up-middleware.d.ts.map

package/dist/better-auth/plugin/lib/sanitize-better-auth-options/utils/use-admin-invite-after-email-sign-up-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-admin-invite-after-email-sign-up-middleware.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/lib/sanitize-better-auth-options/utils/use-admin-invite-after-email-sign-up-middleware.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,wCAAwC,GAAU,gEAI5D;IACD,OAAO,EAAE,0BAA0B,CAAC;IACpC,6BAA6B,EAAE,MAAM,CAAC;IACtC,kBAAkB,EAAE,MAAM,CAAC;CAC5B,kBA8DA,CAAC"}

package/dist/better-auth/plugin/lib/sanitize-better-auth-options/utils/use-admin-invite-after-email-sign-up-middleware.js

@@ -0,0 +1,62 @@
+import { createAuthMiddleware } from "better-auth/api";
+/**
+ * Modifies options object and adds a middleware to check for admin invite for sign up
+ */ export const useAdminInviteAfterEmailSignUpMiddleware = async ({ options, adminInvitationCollectionSlug, userCollectionSlug })=>{
+    options.hooks = options.hooks || {};
+    const originalAfter = options.hooks.after;
+    options.hooks.after = createAuthMiddleware(async (ctx)=>{
+        const adapter = ctx.context.adapter;
+        const internalAdapter = ctx.context.internalAdapter;
+        if (ctx.path !== "/sign-up/email") {
+            if (typeof originalAfter === "function") originalAfter(ctx);
+            return;
+        }
+        const email = ctx.body.email;
+        const adminInviteToken = ctx?.query?.adminInviteToken ?? ctx.body.adminInviteToken;
+        const adminInvitation = await adapter.findOne({
+            model: adminInvitationCollectionSlug,
+            where: [
+                {
+                    field: "token",
+                    value: adminInviteToken,
+                    operator: "eq"
+                }
+            ]
+        });
+        if (!adminInvitation || !adminInvitation?.role || !email) {
+            if (typeof originalAfter === "function") originalAfter(ctx);
+            return;
+        }
+        const newlyCreatedUser = await internalAdapter.findUserByEmail(email);
+        if (!newlyCreatedUser) {
+            if (typeof originalAfter === "function") originalAfter(ctx);
+            return;
+        }
+        await adapter.update({
+            model: userCollectionSlug,
+            where: [
+                {
+                    field: "id",
+                    value: newlyCreatedUser.user.id,
+                    operator: "eq"
+                }
+            ],
+            update: {
+                role: adminInvitation?.role
+            }
+        });
+        await adapter.delete({
+            model: adminInvitationCollectionSlug,
+            where: [
+                {
+                    field: "id",
+                    value: adminInvitation.id,
+                    operator: "eq"
+                }
+            ]
+        });
+        if (typeof originalAfter === "function") originalAfter(ctx);
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/lib/set-login-methods.d.ts

@@ -0,0 +1,5 @@
+import { PayloadAuthOptions } from "../types";
+export declare function setLoginMethods({ pluginOptions }: {
+    pluginOptions: PayloadAuthOptions;
+}): PayloadAuthOptions;
+//# sourceMappingURL=set-login-methods.d.ts.map

package/dist/better-auth/plugin/lib/set-login-methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-login-methods.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/lib/set-login-methods.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAE3D,wBAAgB,eAAe,CAAC,EAC9B,aAAa,EACd,EAAE;IACD,aAAa,EAAE,kBAAkB,CAAC;CACnC,sBAcA"}

package/dist/better-auth/plugin/lib/set-login-methods.js

@@ -0,0 +1,14 @@
+import { supportedBAPluginIds } from "../constants";
+import { checkPluginExists } from "../helpers/check-plugin-exists";
+export function setLoginMethods({ pluginOptions }) {
+    const betterAuthOptions = pluginOptions.betterAuthOptions ?? {};
+    if (pluginOptions?.admin?.loginMethods) return pluginOptions; // If user defined, exit early
+    const loginMethods = Object.keys(betterAuthOptions?.socialProviders ?? {});
+    if (!!betterAuthOptions?.emailAndPassword || betterAuthOptions?.emailAndPassword?.enabled) loginMethods.push("emailPassword");
+    if (checkPluginExists(betterAuthOptions, supportedBAPluginIds.passkey)) loginMethods.push("passkey");
+    pluginOptions.admin = pluginOptions.admin ?? {};
+    pluginOptions.admin.loginMethods = loginMethods;
+    return pluginOptions;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/payload/components/admin-buttons/index.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import "./index.scss";
+interface AdminButtonsProps {
+    userSlug: string;
+    baseURL?: string;
+    basePath?: string;
+}
+export declare function AdminButtons({ baseURL, basePath }: AdminButtonsProps): React.JSX.Element | null;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/better-auth/plugin/payload/components/admin-buttons/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/payload/components/admin-buttons/index.tsx"],"names":[],"mappings":"AAMA,OAAO,KAA4B,MAAM,OAAO,CAAC;AAEjD,OAAO,cAAc,CAAC;AAEtB,UAAU,iBAAiB;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,YAAY,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,iBAAiB,4BA0HpE"}

package/dist/better-auth/plugin/payload/components/admin-buttons/index.js

@@ -0,0 +1,116 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, toast, useDocumentInfo, useFormFields } from "@payloadcms/ui";
+import { adminClient } from "better-auth/client/plugins";
+import { createAuthClient } from "better-auth/react";
+import { useRouter } from "next/navigation";
+import React, { Fragment, useMemo } from "react";
+import "./index.scss";
+export function AdminButtons({ baseURL, basePath }) {
+    const router = useRouter();
+    const { id } = useDocumentInfo();
+    const isBanned = useFormFields(([fields])=>fields.banned);
+    if (!id) {
+        return null;
+    }
+    const authClient = useMemo(()=>createAuthClient({
+            baseURL,
+            basePath,
+            plugins: [
+                adminClient()
+            ]
+        }), []);
+    const handleImpersonate = async ()=>{
+        await authClient.admin.impersonateUser({
+            userId: String(id),
+            fetchOptions: {
+                onSuccess () {
+                    router.push("/");
+                },
+                onError (error) {
+                    console.error("Error impersonating user:", error);
+                    toast.error("Failed to impersonate user");
+                }
+            }
+        });
+    };
+    const handleBan = async ()=>{
+        await authClient.admin.banUser({
+            userId: String(id),
+            fetchOptions: {
+                onSuccess () {
+                    toast.success("User banned successfully");
+                    router.refresh();
+                },
+                onError (error) {
+                    console.error("Error banning user:", error);
+                    toast.error("Failed to ban user");
+                }
+            }
+        });
+    };
+    const handleUnban = async ()=>{
+        await authClient.admin.unbanUser({
+            userId: String(id),
+            fetchOptions: {
+                onSuccess () {
+                    toast.success("User unbanned successfully");
+                    router.refresh();
+                },
+                onError (error) {
+                    console.error("Error unbanning user:", error);
+                    toast.error("Failed to unban user");
+                }
+            }
+        });
+    };
+    const handleRevokeAllSessions = async ()=>{
+        await authClient.admin.revokeUserSessions({
+            userId: String(id),
+            fetchOptions: {
+                onSuccess () {
+                    toast.success("All sessions revoked successfully");
+                    router.refresh();
+                },
+                onError (error) {
+                    console.error("Error revoking all sessions:", error);
+                    toast.error("Failed to revoke all sessions");
+                }
+            }
+        });
+    };
+    return /*#__PURE__*/ _jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ _jsx(Button, {
+                onClick: handleImpersonate,
+                buttonStyle: "pill",
+                className: "impersonate-button",
+                size: "medium",
+                children: "Impersonate"
+            }),
+            /*#__PURE__*/ _jsx(Button, {
+                onClick: handleRevokeAllSessions,
+                buttonStyle: "secondary",
+                className: "revoke-sessions-button",
+                size: "medium",
+                children: "Revoke All Sessions"
+            }),
+            !isBanned ? /*#__PURE__*/ _jsx(Button, {
+                onClick: handleBan,
+                buttonStyle: "error",
+                className: "ban-button",
+                size: "medium",
+                children: "Ban"
+            }) : null,
+            isBanned ? /*#__PURE__*/ _jsx(Button, {
+                onClick: handleUnban,
+                buttonStyle: "primary",
+                className: "unban-button",
+                size: "medium",
+                children: "Unban"
+            }) : null
+        ]
+    });
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/payload/components/admin-buttons/index.scss

@@ -0,0 +1,36 @@
+.doc-tabs__tabs:has(.impersonate-button) .doc-tab {
+  order: 10;
+}
+
+.impersonate-button,
+.revoke-sessions-button,
+.ban-button,
+.unban-button {
+  display: inline-flex;
+  align-items: center;
+  margin-block: 0;
+  padding-block: 0.23rem;
+  text-wrap: nowrap;
+}
+
+.ban-button {
+  background-color: oklch(0.258 0.092 26.042);
+  color: oklch(0.577 0.245 27.325);
+  border: 1px solid oklch(0.396 0.141 25.723);
+
+  &:hover {
+    color: #fff;
+    background-color: oklch(0.505 0.213 27.518);
+  }
+}
+
+.revoke-sessions-button {
+  --theme-elevation-800: oklch(0.396 0.141 25.723);
+  color: oklch(0.637 0.237 25.331);
+
+  &:hover {
+    --theme-elevation-400: oklch(0.396 0.141 25.723);
+    color: #fff;
+    background-color: oklch(0.396 0.141 25.723);
+  }
+}

package/dist/better-auth/plugin/payload/components/admin-invite-button/index.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import "./index.scss";
+interface AdminInviteButtonProps {
+    roles: {
+        label: string;
+        value: string;
+    }[];
+}
+export declare function AdminInviteButton({ roles }: AdminInviteButtonProps): React.JSX.Element | null;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/better-auth/plugin/payload/components/admin-invite-button/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/payload/components/admin-invite-button/index.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAmB,MAAM,OAAO,CAAC;AAGxC,OAAO,cAAc,CAAC;AAItB,UAAU,sBAAsB;IAC9B,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC3C;AAED,wBAAgB,iBAAiB,CAAC,EAAE,KAAK,EAAE,EAAE,sBAAsB,4BA0MlE"}