@luochuanyuewu/payload-auth 1.8.0

package/dist/better-auth/plugin/constants.js

@@ -0,0 +1,259 @@
+export const socialProviders = [
+    "apple",
+    "discord",
+    "facebook",
+    "github",
+    "google",
+    "linkedin",
+    "microsoft",
+    "spotify",
+    "tiktok",
+    "twitter",
+    "twitch",
+    "zoom",
+    "gitlab",
+    "roblox",
+    "vk",
+    "kick",
+    "reddit"
+];
+export const loginMethods = [
+    "emailPassword",
+    "magicLink",
+    "emailOTP",
+    "phonePassword",
+    "phoneOTP",
+    "phoneMagicLink",
+    "passkey",
+    ...socialProviders
+];
+export const supportedBAPluginIds = {
+    oneTimeToken: "one-time-token",
+    oAuthProxy: "oauth-proxy",
+    haveIBeenPwned: "haveIBeenPwned",
+    captcha: "captcha",
+    bearer: "bearer",
+    genericOAuth: "generic-oauth",
+    customSession: "custom-session",
+    harmonyEmail: "harmony-email",
+    harmonyPhoneNumber: "harmony-phone-number",
+    twoFactor: "two-factor",
+    username: "username",
+    anonymous: "anonymous",
+    phoneNumber: "phone-number",
+    magicLink: "magic-link",
+    emailOtp: "email-otp",
+    passkey: "passkey",
+    oneTap: "one-tap",
+    admin: "admin",
+    apiKey: "api-key",
+    mcp: "mcp",
+    organization: "organization",
+    multiSession: "multi-session",
+    openApi: "open-api",
+    jwt: "jwt",
+    nextCookies: "next-cookies",
+    sso: "sso",
+    oidc: "oidc",
+    expo: "expo",
+    polar: "polar",
+    stripe: "stripe",
+    autumn: "autumn",
+    dodopayments: "dodopayments",
+    dubAnalytics: "dub-analytics",
+    deviceAuthorization: "device-authorization",
+    lastLoginMethod: "last-login-method",
+    scim: "scim"
+};
+export const baseSlugs = {
+    users: "users",
+    sessions: "sessions",
+    accounts: "accounts",
+    verifications: "verifications",
+    adminInvitations: "admin-invitations"
+};
+export const baPluginSlugs = {
+    subscriptions: "subscriptions",
+    apiKeys: "apiKeys",
+    jwks: "jwks",
+    twoFactors: "twoFactors",
+    passkeys: "passkeys",
+    oauthApplications: "oauthApplications",
+    oauthAccessTokens: "oauthAccessTokens",
+    oauthConsents: "oauthConsents",
+    ssoProviders: "ssoProviders",
+    organizations: "organizations",
+    organizationRoles: "organizationRoles",
+    invitations: "invitations",
+    members: "members",
+    teams: "teams",
+    teamMembers: "teamMembers",
+    scim: "scimProvider",
+    rateLimit: "rateLimit"
+};
+export const baModelKey = {
+    user: "user",
+    session: "session",
+    account: "account",
+    verification: "verification",
+    twoFactor: "twoFactor",
+    passkey: "passkey",
+    oauthApplication: "oauthApplication",
+    oauthAccessToken: "oauthAccessToken",
+    oauthConsent: "oauthConsent",
+    ssoProvider: "ssoProvider",
+    organization: "organization",
+    organizationRole: "organizationRole",
+    invitation: "invitation",
+    member: "member",
+    team: "team",
+    teamMember: "teamMember",
+    subscription: "subscription",
+    apikey: "apikey",
+    jwks: "jwks",
+    deviceCode: "deviceCode",
+    rateLimit: "rateLimit",
+    scimProvider: "scimProvider"
+};
+export const baModelFieldKeysToFieldNames = {
+    user: {
+        role: "role"
+    },
+    account: {
+        userId: "user"
+    },
+    session: {
+        userId: "user"
+    },
+    member: {
+        organizationId: "organization",
+        userId: "user",
+        teamId: "team"
+    },
+    invitation: {
+        organizationId: "organization",
+        inviterId: "inviter",
+        teamId: "team"
+    },
+    team: {
+        organizationId: "organization"
+    },
+    apikey: {
+        userId: "user"
+    },
+    twoFactor: {
+        userId: "user"
+    },
+    passkey: {
+        userId: "user"
+    },
+    ssoProvider: {
+        userId: "user"
+    },
+    oauthApplication: {
+        userId: "user"
+    },
+    oauthAccessToken: {
+        userId: "user",
+        clientId: "client"
+    },
+    oauthConsent: {
+        userId: "user",
+        clientId: "client"
+    }
+};
+export const baModelFieldKeys = {
+    organizationRole: {
+        organizationId: "organizationId"
+    },
+    teamMember: {
+        teamId: "teamId",
+        userId: "userId"
+    },
+    account: {
+        userId: "userId"
+    },
+    session: {
+        userId: "userId",
+        activeOrganizationId: "activeOrganizationId",
+        impersonatedBy: "impersonatedBy",
+        activeTeamId: "activeTeamId"
+    },
+    member: {
+        organizationId: "organizationId",
+        userId: "userId",
+        teamId: "teamId"
+    },
+    invitation: {
+        organizationId: "organizationId",
+        inviterId: "inviterId",
+        teamId: "teamId"
+    },
+    team: {
+        organizationId: "organizationId"
+    },
+    apikey: {
+        userId: "userId"
+    },
+    twoFactor: {
+        userId: "userId"
+    },
+    passkey: {
+        userId: "userId"
+    },
+    ssoProvider: {
+        userId: "userId"
+    },
+    oauthApplication: {
+        userId: "userId"
+    },
+    oauthAccessToken: {
+        userId: "userId",
+        clientId: "clientId"
+    },
+    oauthConsent: {
+        userId: "userId",
+        clientId: "clientId"
+    }
+};
+export const baModelKeyToSlug = {
+    user: baseSlugs.users,
+    session: baseSlugs.sessions,
+    account: baseSlugs.accounts,
+    verification: baseSlugs.verifications,
+    twoFactor: baPluginSlugs.twoFactors,
+    passkey: baPluginSlugs.passkeys,
+    oauthApplication: baPluginSlugs.oauthApplications,
+    oauthAccessToken: baPluginSlugs.oauthAccessTokens,
+    oauthConsent: baPluginSlugs.oauthConsents,
+    ssoProvider: baPluginSlugs.ssoProviders,
+    organization: baPluginSlugs.organizations,
+    invitation: baPluginSlugs.invitations,
+    member: baPluginSlugs.members,
+    team: baPluginSlugs.teams,
+    teamMember: baPluginSlugs.teamMembers,
+    subscription: baPluginSlugs.subscriptions,
+    apikey: baPluginSlugs.apiKeys,
+    jwks: baPluginSlugs.jwks
+};
+export const adminRoutes = {
+    forgotPassword: "/forgot-password",
+    resetPassword: "/reset-password",
+    adminSignup: "/signup",
+    adminLogin: "/login",
+    loginRedirect: "/login-redirect",
+    twoFactorVerify: "/two-factor-verify"
+};
+export const adminEndpoints = {
+    setAdminRole: "/set-admin-role",
+    refreshToken: "/refresh-token",
+    sendInvite: "/send-invite",
+    generateInviteUrl: "/generate-invite-url",
+    signup: "/signup"
+};
+export const defaults = {
+    adminRole: "admin",
+    userRole: "user"
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/better-auth/plugin/constants.ts"],"sourcesContent":["export const socialProviders = [\n  \"apple\",\n  \"discord\",\n  \"facebook\",\n  \"github\",\n  \"google\",\n  \"linkedin\",\n  \"microsoft\",\n  \"spotify\",\n  \"tiktok\",\n  \"twitter\",\n  \"twitch\",\n  \"zoom\",\n  \"gitlab\",\n  \"roblox\",\n  \"vk\",\n  \"kick\",\n  \"reddit\"\n] as const;\n\nexport const loginMethods = [\n  \"emailPassword\",\n  \"magicLink\",\n  \"emailOTP\",\n  \"phonePassword\",\n  \"phoneOTP\",\n  \"phoneMagicLink\",\n  \"passkey\",\n  ...socialProviders\n] as const;\n\nexport const supportedBAPluginIds = {\n  oneTimeToken: \"one-time-token\",\n  oAuthProxy: \"oauth-proxy\",\n  haveIBeenPwned: \"haveIBeenPwned\",\n  captcha: \"captcha\",\n  bearer: \"bearer\",\n  genericOAuth: \"generic-oauth\",\n  customSession: \"custom-session\",\n  harmonyEmail: \"harmony-email\",\n  harmonyPhoneNumber: \"harmony-phone-number\",\n  twoFactor: \"two-factor\",\n  username: \"username\",\n  anonymous: \"anonymous\",\n  phoneNumber: \"phone-number\",\n  magicLink: \"magic-link\",\n  emailOtp: \"email-otp\",\n  passkey: \"passkey\",\n  oneTap: \"one-tap\",\n  admin: \"admin\",\n  apiKey: \"api-key\",\n  mcp: \"mcp\",\n  organization: \"organization\",\n  multiSession: \"multi-session\",\n  openApi: \"open-api\",\n  jwt: \"jwt\",\n  nextCookies: \"next-cookies\",\n  sso: \"sso\",\n  oidc: \"oidc\",\n  expo: \"expo\",\n  polar: \"polar\",\n  stripe: \"stripe\",\n  autumn: \"autumn\",\n  dodopayments: \"dodopayments\",\n  dubAnalytics: \"dub-analytics\",\n  deviceAuthorization: \"device-authorization\",\n  lastLoginMethod: \"last-login-method\",\n  scim: \"scim\"\n} as const;\n\nexport const baseSlugs = {\n  users: \"users\",\n  sessions: \"sessions\",\n  accounts: \"accounts\",\n  verifications: \"verifications\",\n  adminInvitations: \"admin-invitations\"\n} as const;\n\nexport const baPluginSlugs = {\n  subscriptions: \"subscriptions\",\n  apiKeys: \"apiKeys\",\n  jwks: \"jwks\",\n  twoFactors: \"twoFactors\",\n  passkeys: \"passkeys\",\n  oauthApplications: \"oauthApplications\",\n  oauthAccessTokens: \"oauthAccessTokens\",\n  oauthConsents: \"oauthConsents\",\n  ssoProviders: \"ssoProviders\",\n  organizations: \"organizations\",\n  organizationRoles: \"organizationRoles\",\n  invitations: \"invitations\",\n  members: \"members\",\n  teams: \"teams\",\n  teamMembers: \"teamMembers\",\n  scim: \"scimProvider\",\n  rateLimit: \"rateLimit\"\n} as const;\n\nexport const baModelKey = {\n  user: \"user\",\n  session: \"session\",\n  account: \"account\",\n  verification: \"verification\",\n  twoFactor: \"twoFactor\",\n  passkey: \"passkey\",\n  oauthApplication: \"oauthApplication\",\n  oauthAccessToken: \"oauthAccessToken\",\n  oauthConsent: \"oauthConsent\",\n  ssoProvider: \"ssoProvider\",\n  organization: \"organization\",\n  organizationRole: \"organizationRole\",\n  invitation: \"invitation\",\n  member: \"member\",\n  team: \"team\",\n  teamMember: \"teamMember\",\n  subscription: \"subscription\",\n  apikey: \"apikey\",\n  jwks: \"jwks\",\n  deviceCode: \"deviceCode\",\n  rateLimit: \"rateLimit\",\n  scimProvider: \"scimProvider\"\n} as const;\n\nexport const baModelFieldKeysToFieldNames = {\n  user: {\n    role: \"role\"\n  },\n  account: {\n    userId: \"user\"\n  },\n  session: {\n    userId: \"user\"\n  },\n  member: {\n    organizationId: \"organization\",\n    userId: \"user\",\n    teamId: \"team\"\n  },\n  invitation: {\n    organizationId: \"organization\",\n    inviterId: \"inviter\",\n    teamId: \"team\"\n  },\n  team: {\n    organizationId: \"organization\"\n  },\n  apikey: {\n    userId: \"user\"\n  },\n  twoFactor: {\n    userId: \"user\"\n  },\n  passkey: {\n    userId: \"user\"\n  },\n  ssoProvider: {\n    userId: \"user\"\n  },\n  oauthApplication: {\n    userId: \"user\"\n  },\n  oauthAccessToken: {\n    userId: \"user\",\n    clientId: \"client\"\n  },\n  oauthConsent: {\n    userId: \"user\",\n    clientId: \"client\"\n  }\n} as const;\n\nexport const baModelFieldKeys = {\n  organizationRole: {\n    organizationId: \"organizationId\"\n  },\n  teamMember: {\n    teamId: \"teamId\",\n    userId: \"userId\"\n  },\n  account: {\n    userId: \"userId\"\n  },\n  session: {\n    userId: \"userId\",\n    activeOrganizationId: \"activeOrganizationId\",\n    impersonatedBy: \"impersonatedBy\",\n    activeTeamId: \"activeTeamId\"\n  },\n  member: {\n    organizationId: \"organizationId\",\n    userId: \"userId\",\n    teamId: \"teamId\"\n  },\n  invitation: {\n    organizationId: \"organizationId\",\n    inviterId: \"inviterId\",\n    teamId: \"teamId\"\n  },\n  team: {\n    organizationId: \"organizationId\"\n  },\n  apikey: {\n    userId: \"userId\"\n  },\n  twoFactor: {\n    userId: \"userId\"\n  },\n  passkey: {\n    userId: \"userId\"\n  },\n  ssoProvider: {\n    userId: \"userId\"\n  },\n  oauthApplication: {\n    userId: \"userId\"\n  },\n  oauthAccessToken: {\n    userId: \"userId\",\n    clientId: \"clientId\"\n  },\n  oauthConsent: {\n    userId: \"userId\",\n    clientId: \"clientId\"\n  }\n} as const;\n\nexport const baModelKeyToSlug = {\n  user: baseSlugs.users,\n  session: baseSlugs.sessions,\n  account: baseSlugs.accounts,\n  verification: baseSlugs.verifications,\n  twoFactor: baPluginSlugs.twoFactors,\n  passkey: baPluginSlugs.passkeys,\n  oauthApplication: baPluginSlugs.oauthApplications,\n  oauthAccessToken: baPluginSlugs.oauthAccessTokens,\n  oauthConsent: baPluginSlugs.oauthConsents,\n  ssoProvider: baPluginSlugs.ssoProviders,\n  organization: baPluginSlugs.organizations,\n  invitation: baPluginSlugs.invitations,\n  member: baPluginSlugs.members,\n  team: baPluginSlugs.teams,\n  teamMember: baPluginSlugs.teamMembers,\n  subscription: baPluginSlugs.subscriptions,\n  apikey: baPluginSlugs.apiKeys,\n  jwks: baPluginSlugs.jwks\n} as const;\n\nexport const adminRoutes = {\n  forgotPassword: \"/forgot-password\",\n  resetPassword: \"/reset-password\",\n  adminSignup: \"/signup\",\n  adminLogin: \"/login\",\n  loginRedirect: \"/login-redirect\",\n  twoFactorVerify: \"/two-factor-verify\"\n} as const;\n\nexport const adminEndpoints = {\n  setAdminRole: \"/set-admin-role\",\n  refreshToken: \"/refresh-token\",\n  sendInvite: \"/send-invite\",\n  generateInviteUrl: \"/generate-invite-url\",\n  signup: \"/signup\"\n} as const;\n\nexport const defaults = {\n  adminRole: \"admin\",\n  userRole: \"user\"\n} as const;\n"],"names":["socialProviders","loginMethods","supportedBAPluginIds","oneTimeToken","oAuthProxy","haveIBeenPwned","captcha","bearer","genericOAuth","customSession","harmonyEmail","harmonyPhoneNumber","twoFactor","username","anonymous","phoneNumber","magicLink","emailOtp","passkey","oneTap","admin","apiKey","mcp","organization","multiSession","openApi","jwt","nextCookies","sso","oidc","expo","polar","stripe","autumn","dodopayments","dubAnalytics","deviceAuthorization","lastLoginMethod","scim","baseSlugs","users","sessions","accounts","verifications","adminInvitations","baPluginSlugs","subscriptions","apiKeys","jwks","twoFactors","passkeys","oauthApplications","oauthAccessTokens","oauthConsents","ssoProviders","organizations","organizationRoles","invitations","members","teams","teamMembers","rateLimit","baModelKey","user","session","account","verification","oauthApplication","oauthAccessToken","oauthConsent","ssoProvider","organizationRole","invitation","member","team","teamMember","subscription","apikey","deviceCode","scimProvider","baModelFieldKeysToFieldNames","role","userId","organizationId","teamId","inviterId","clientId","baModelFieldKeys","activeOrganizationId","impersonatedBy","activeTeamId","baModelKeyToSlug","adminRoutes","forgotPassword","resetPassword","adminSignup","adminLogin","loginRedirect","twoFactorVerify","adminEndpoints","setAdminRole","refreshToken","sendInvite","generateInviteUrl","signup","defaults","adminRole","userRole"],"mappings":"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"}

package/dist/better-auth/plugin/helpers/check-plugin-exists.d.ts

@@ -0,0 +1,13 @@
+import type { BetterAuthOptions } from "../types";
+/**
+ * Checks if a plugin with the specified ID exists in the Better Auth options
+ *
+ * This utility function examines the plugins array in the provided Better Auth options
+ * to determine if a plugin with the given ID is already registered.
+ *
+ * @param options - The Better Auth configuration options
+ * @param pluginId - The unique identifier of the plugin to check for
+ * @returns `true` if a plugin with the specified ID exists, `false` otherwise
+ */
+export declare function checkPluginExists(options: BetterAuthOptions, pluginId: string): boolean;
+//# sourceMappingURL=check-plugin-exists.d.ts.map

package/dist/better-auth/plugin/helpers/check-plugin-exists.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-plugin-exists.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/check-plugin-exists.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,iBAAiB,EAC1B,QAAQ,EAAE,MAAM,GACf,OAAO,CAET"}

package/dist/better-auth/plugin/helpers/check-plugin-exists.js

@@ -0,0 +1,14 @@
+/**
+ * Checks if a plugin with the specified ID exists in the Better Auth options
+ *
+ * This utility function examines the plugins array in the provided Better Auth options
+ * to determine if a plugin with the given ID is already registered.
+ *
+ * @param options - The Better Auth configuration options
+ * @param pluginId - The unique identifier of the plugin to check for
+ * @returns `true` if a plugin with the specified ID exists, `false` otherwise
+ */ export function checkPluginExists(options, pluginId) {
+    return options.plugins?.some((plugin)=>plugin.id === pluginId) || false;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iZXR0ZXItYXV0aC9wbHVnaW4vaGVscGVycy9jaGVjay1wbHVnaW4tZXhpc3RzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgQmV0dGVyQXV0aE9wdGlvbnMgfSBmcm9tIFwiLi4vdHlwZXNcIjtcblxuLyoqXG4gKiBDaGVja3MgaWYgYSBwbHVnaW4gd2l0aCB0aGUgc3BlY2lmaWVkIElEIGV4aXN0cyBpbiB0aGUgQmV0dGVyIEF1dGggb3B0aW9uc1xuICpcbiAqIFRoaXMgdXRpbGl0eSBmdW5jdGlvbiBleGFtaW5lcyB0aGUgcGx1Z2lucyBhcnJheSBpbiB0aGUgcHJvdmlkZWQgQmV0dGVyIEF1dGggb3B0aW9uc1xuICogdG8gZGV0ZXJtaW5lIGlmIGEgcGx1Z2luIHdpdGggdGhlIGdpdmVuIElEIGlzIGFscmVhZHkgcmVnaXN0ZXJlZC5cbiAqXG4gKiBAcGFyYW0gb3B0aW9ucyAtIFRoZSBCZXR0ZXIgQXV0aCBjb25maWd1cmF0aW9uIG9wdGlvbnNcbiAqIEBwYXJhbSBwbHVnaW5JZCAtIFRoZSB1bmlxdWUgaWRlbnRpZmllciBvZiB0aGUgcGx1Z2luIHRvIGNoZWNrIGZvclxuICogQHJldHVybnMgYHRydWVgIGlmIGEgcGx1Z2luIHdpdGggdGhlIHNwZWNpZmllZCBJRCBleGlzdHMsIGBmYWxzZWAgb3RoZXJ3aXNlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjaGVja1BsdWdpbkV4aXN0cyhcbiAgb3B0aW9uczogQmV0dGVyQXV0aE9wdGlvbnMsXG4gIHBsdWdpbklkOiBzdHJpbmdcbik6IGJvb2xlYW4ge1xuICByZXR1cm4gb3B0aW9ucy5wbHVnaW5zPy5zb21lKChwbHVnaW4pID0+IHBsdWdpbi5pZCA9PT0gcGx1Z2luSWQpIHx8IGZhbHNlO1xufVxuIl0sIm5hbWVzIjpbImNoZWNrUGx1Z2luRXhpc3RzIiwib3B0aW9ucyIsInBsdWdpbklkIiwicGx1Z2lucyIsInNvbWUiLCJwbHVnaW4iLCJpZCJdLCJtYXBwaW5ncyI6IkFBRUE7Ozs7Ozs7OztDQVNDLEdBQ0QsT0FBTyxTQUFTQSxrQkFDZEMsT0FBMEIsRUFDMUJDLFFBQWdCO0lBRWhCLE9BQU9ELFFBQVFFLE9BQU8sRUFBRUMsS0FBSyxDQUFDQyxTQUFXQSxPQUFPQyxFQUFFLEtBQUtKLGFBQWE7QUFDdEUifQ==

package/dist/better-auth/plugin/helpers/generate-verify-email-url.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Generates a verification URL for email verification
+ *
+ * This utility function creates a JWT token containing the user's email and
+ * expiration information, signs it with the provided secret, and constructs
+ * a verification URL with the token as a query parameter.
+ *
+ * @param userEmail - The email address of the user to verify
+ * @param secret - The secret used to sign the JWT
+ * @param expiresIn - Duration in seconds for token expiration (default: 3600)
+ * @param verifyRouteUrl - The base URL for the verification endpoint
+ * @param callbackURL - Optional callback URL after verification (default: "/")
+ * @returns The complete verification URL with token
+ *
+ * @example
+ * const url = await generateVerifyEmailUrl({
+ *   userEmail: 'user@example.com',
+ *   secret: 'your-secret-key',
+ *   verifyRouteUrl: 'https://your-app.com/api/auth/verify-email',
+ *   callbackURL: '/profile'
+ * });
+ */
+export declare const generateVerifyEmailUrl: ({ userEmail, secret, expiresIn, verifyRouteUrl, callbackURL }: {
+    userEmail: string;
+    secret: string;
+    expiresIn?: number;
+    verifyRouteUrl: string;
+    callbackURL?: string;
+}) => Promise<string>;
+//# sourceMappingURL=generate-verify-email-url.d.ts.map

package/dist/better-auth/plugin/helpers/generate-verify-email-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-verify-email-url.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/generate-verify-email-url.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,sBAAsB,GAAU,+DAM1C;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,KAAG,OAAO,CAAC,MAAM,CA4BjB,CAAC"}

package/dist/better-auth/plugin/helpers/generate-verify-email-url.js

@@ -0,0 +1,46 @@
+import { SignJWT } from "jose";
+/**
+ * Generates a verification URL for email verification
+ *
+ * This utility function creates a JWT token containing the user's email and
+ * expiration information, signs it with the provided secret, and constructs
+ * a verification URL with the token as a query parameter.
+ *
+ * @param userEmail - The email address of the user to verify
+ * @param secret - The secret used to sign the JWT
+ * @param expiresIn - Duration in seconds for token expiration (default: 3600)
+ * @param verifyRouteUrl - The base URL for the verification endpoint
+ * @param callbackURL - Optional callback URL after verification (default: "/")
+ * @returns The complete verification URL with token
+ *
+ * @example
+ * const url = await generateVerifyEmailUrl({
+ *   userEmail: 'user@example.com',
+ *   secret: 'your-secret-key',
+ *   verifyRouteUrl: 'https://your-app.com/api/auth/verify-email',
+ *   callbackURL: '/profile'
+ * });
+ */ export const generateVerifyEmailUrl = async ({ userEmail, secret, expiresIn = 3600, verifyRouteUrl, callbackURL = "/" })=>{
+    if (!userEmail) {
+        throw new Error("userEmail is required to generate a verification URL");
+    }
+    if (!secret) {
+        throw new Error("secret is required to sign the JWT token");
+    }
+    if (!verifyRouteUrl) {
+        throw new Error("verifyRouteUrl is required to generate a verification URL");
+    }
+    // Create and sign the JWT token
+    const jwt = await new SignJWT({
+        email: userEmail,
+        iat: Math.floor(Date.now() / 1000),
+        exp: Math.floor(Date.now() / 1000) + expiresIn
+    }).setProtectedHeader({
+        alg: "HS256"
+    }).sign(new TextEncoder().encode(secret));
+    // Build the verification URL
+    const verifyUrl = `${verifyRouteUrl}?token=${jwt}${callbackURL ? `&callbackURL=${encodeURIComponent(callbackURL)}` : ""}`;
+    return verifyUrl;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/helpers/get-admin-access.d.ts

@@ -0,0 +1,8 @@
+import type { PayloadAuthOptions } from "@/better-auth/plugin/types";
+export declare function getAdminAccess(pluginOptions: PayloadAuthOptions): {
+    create: import("payload").FieldAccess;
+    read: import("payload").FieldAccess;
+    update: import("payload").FieldAccess;
+    delete: import("payload").FieldAccess;
+};
+//# sourceMappingURL=get-admin-access.d.ts.map

package/dist/better-auth/plugin/helpers/get-admin-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-admin-access.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/get-admin-access.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAGrE,wBAAgB,cAAc,CAAC,aAAa,EAAE,kBAAkB;;;;;EAgB/D"}

package/dist/better-auth/plugin/helpers/get-admin-access.js

@@ -0,0 +1,22 @@
+import { isAdminWithRoles } from "../lib/build-collections/utils/payload-access";
+export function getAdminAccess(pluginOptions) {
+    const adminRoles = pluginOptions.users?.adminRoles ?? [
+        "admin"
+    ];
+    return {
+        create: isAdminWithRoles({
+            adminRoles
+        }),
+        read: isAdminWithRoles({
+            adminRoles
+        }),
+        update: isAdminWithRoles({
+            adminRoles
+        }),
+        delete: isAdminWithRoles({
+            adminRoles
+        })
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iZXR0ZXItYXV0aC9wbHVnaW4vaGVscGVycy9nZXQtYWRtaW4tYWNjZXNzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgUGF5bG9hZEF1dGhPcHRpb25zIH0gZnJvbSBcIkAvYmV0dGVyLWF1dGgvcGx1Z2luL3R5cGVzXCI7XG5pbXBvcnQgeyBpc0FkbWluV2l0aFJvbGVzIH0gZnJvbSBcIi4uL2xpYi9idWlsZC1jb2xsZWN0aW9ucy91dGlscy9wYXlsb2FkLWFjY2Vzc1wiO1xuXG5leHBvcnQgZnVuY3Rpb24gZ2V0QWRtaW5BY2Nlc3MocGx1Z2luT3B0aW9uczogUGF5bG9hZEF1dGhPcHRpb25zKSB7XG4gIGNvbnN0IGFkbWluUm9sZXMgPSBwbHVnaW5PcHRpb25zLnVzZXJzPy5hZG1pblJvbGVzID8/IFtcImFkbWluXCJdO1xuICByZXR1cm4ge1xuICAgIGNyZWF0ZTogaXNBZG1pbldpdGhSb2xlcyh7XG4gICAgICBhZG1pblJvbGVzXG4gICAgfSksXG4gICAgcmVhZDogaXNBZG1pbldpdGhSb2xlcyh7XG4gICAgICBhZG1pblJvbGVzXG4gICAgfSksXG4gICAgdXBkYXRlOiBpc0FkbWluV2l0aFJvbGVzKHtcbiAgICAgIGFkbWluUm9sZXNcbiAgICB9KSxcbiAgICBkZWxldGU6IGlzQWRtaW5XaXRoUm9sZXMoe1xuICAgICAgYWRtaW5Sb2xlc1xuICAgIH0pXG4gIH07XG59XG4iXSwibmFtZXMiOlsiaXNBZG1pbldpdGhSb2xlcyIsImdldEFkbWluQWNjZXNzIiwicGx1Z2luT3B0aW9ucyIsImFkbWluUm9sZXMiLCJ1c2VycyIsImNyZWF0ZSIsInJlYWQiLCJ1cGRhdGUiLCJkZWxldGUiXSwibWFwcGluZ3MiOiJBQUNBLFNBQVNBLGdCQUFnQixRQUFRLGdEQUFnRDtBQUVqRixPQUFPLFNBQVNDLGVBQWVDLGFBQWlDO0lBQzlELE1BQU1DLGFBQWFELGNBQWNFLEtBQUssRUFBRUQsY0FBYztRQUFDO0tBQVE7SUFDL0QsT0FBTztRQUNMRSxRQUFRTCxpQkFBaUI7WUFDdkJHO1FBQ0Y7UUFDQUcsTUFBTU4saUJBQWlCO1lBQ3JCRztRQUNGO1FBQ0FJLFFBQVFQLGlCQUFpQjtZQUN2Qkc7UUFDRjtRQUNBSyxRQUFRUixpQkFBaUI7WUFDdkJHO1FBQ0Y7SUFDRjtBQUNGIn0=

package/dist/better-auth/plugin/helpers/get-all-roles.d.ts

@@ -0,0 +1,6 @@
+import type { PayloadAuthOptions } from "@/better-auth/plugin/types";
+export declare function getAllRoleOptions(pluginOptions: PayloadAuthOptions): {
+    label: string;
+    value: string;
+}[];
+//# sourceMappingURL=get-all-roles.d.ts.map

package/dist/better-auth/plugin/helpers/get-all-roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-all-roles.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/get-all-roles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAErE,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,kBAAkB;;;IAalE"}

package/dist/better-auth/plugin/helpers/get-all-roles.js

@@ -0,0 +1,20 @@
+export function getAllRoleOptions(pluginOptions) {
+    const adminRoles = pluginOptions.users?.adminRoles ?? [
+        "admin"
+    ];
+    const roles = pluginOptions.users?.roles ?? [
+        "user"
+    ];
+    const allRoleOptions = [
+        ...new Set([
+            ...adminRoles,
+            ...roles
+        ])
+    ].map((role)=>({
+            label: role.split(/[-_\s]/).map((word)=>word.charAt(0).toUpperCase() + word.slice(1)).join(" "),
+            value: role
+        }));
+    return allRoleOptions;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iZXR0ZXItYXV0aC9wbHVnaW4vaGVscGVycy9nZXQtYWxsLXJvbGVzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgUGF5bG9hZEF1dGhPcHRpb25zIH0gZnJvbSBcIkAvYmV0dGVyLWF1dGgvcGx1Z2luL3R5cGVzXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRBbGxSb2xlT3B0aW9ucyhwbHVnaW5PcHRpb25zOiBQYXlsb2FkQXV0aE9wdGlvbnMpIHtcbiAgY29uc3QgYWRtaW5Sb2xlcyA9IHBsdWdpbk9wdGlvbnMudXNlcnM/LmFkbWluUm9sZXMgPz8gW1wiYWRtaW5cIl07XG4gIGNvbnN0IHJvbGVzID0gcGx1Z2luT3B0aW9ucy51c2Vycz8ucm9sZXMgPz8gW1widXNlclwiXTtcbiAgY29uc3QgYWxsUm9sZU9wdGlvbnMgPSBbLi4ubmV3IFNldChbLi4uYWRtaW5Sb2xlcywgLi4ucm9sZXNdKV0ubWFwKFxuICAgIChyb2xlKSA9PiAoe1xuICAgICAgbGFiZWw6IHJvbGVcbiAgICAgICAgLnNwbGl0KC9bLV9cXHNdLylcbiAgICAgICAgLm1hcCgod29yZCkgPT4gd29yZC5jaGFyQXQoMCkudG9VcHBlckNhc2UoKSArIHdvcmQuc2xpY2UoMSkpXG4gICAgICAgIC5qb2luKFwiIFwiKSxcbiAgICAgIHZhbHVlOiByb2xlXG4gICAgfSlcbiAgKTtcbiAgcmV0dXJuIGFsbFJvbGVPcHRpb25zO1xufVxuIl0sIm5hbWVzIjpbImdldEFsbFJvbGVPcHRpb25zIiwicGx1Z2luT3B0aW9ucyIsImFkbWluUm9sZXMiLCJ1c2VycyIsInJvbGVzIiwiYWxsUm9sZU9wdGlvbnMiLCJTZXQiLCJtYXAiLCJyb2xlIiwibGFiZWwiLCJzcGxpdCIsIndvcmQiLCJjaGFyQXQiLCJ0b1VwcGVyQ2FzZSIsInNsaWNlIiwiam9pbiIsInZhbHVlIl0sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLFNBQVNBLGtCQUFrQkMsYUFBaUM7SUFDakUsTUFBTUMsYUFBYUQsY0FBY0UsS0FBSyxFQUFFRCxjQUFjO1FBQUM7S0FBUTtJQUMvRCxNQUFNRSxRQUFRSCxjQUFjRSxLQUFLLEVBQUVDLFNBQVM7UUFBQztLQUFPO0lBQ3BELE1BQU1DLGlCQUFpQjtXQUFJLElBQUlDLElBQUk7ZUFBSUo7ZUFBZUU7U0FBTTtLQUFFLENBQUNHLEdBQUcsQ0FDaEUsQ0FBQ0MsT0FBVSxDQUFBO1lBQ1RDLE9BQU9ELEtBQ0pFLEtBQUssQ0FBQyxVQUNOSCxHQUFHLENBQUMsQ0FBQ0ksT0FBU0EsS0FBS0MsTUFBTSxDQUFDLEdBQUdDLFdBQVcsS0FBS0YsS0FBS0csS0FBSyxDQUFDLElBQ3hEQyxJQUFJLENBQUM7WUFDUkMsT0FBT1I7UUFDVCxDQUFBO0lBRUYsT0FBT0g7QUFDVCJ9

package/dist/better-auth/plugin/helpers/get-better-auth-schema.d.ts

@@ -0,0 +1,19 @@
+import { BetterAuthSchemas, PayloadAuthOptions } from "../types";
+/**
+ * A consistent BetterAuth schema generator.
+ *
+ * Differences from the original `getSchema` implementation in BetterAuth:
+ * 1. Keys in the returned object are always the **static table identifiers** coming from
+ *    `getAuthTables`, never the possibly-overridden `modelName`.  This guarantees that
+ *    subsequent look-ups remain stable even if the user renames collections.
+ * 2. Each schema entry now contains an explicit `modelName` property exposing the current
+ *    (potentially user-overridden) model name, while `fields` continue to be referenced by
+ *    their static BetterAuth field keys.
+ * 3. When converting fields, we store them under their original key (`actualFields[key] = field`)
+ *    instead of `field.fieldName || key` to avoid accidental renames.
+ *
+ * @param config - The BetterAuth options fed into `getAuthTables`.
+ * @returns A map keyed by static table keys, each value containing `{ modelName, fields, order }`.
+ */
+export declare function getDefaultBetterAuthSchema(pluginOptions: PayloadAuthOptions): BetterAuthSchemas;
+//# sourceMappingURL=get-better-auth-schema.d.ts.map

package/dist/better-auth/plugin/helpers/get-better-auth-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-better-auth-schema.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/get-better-auth-schema.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAIjE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,0BAA0B,CACxC,aAAa,EAAE,kBAAkB,GAChC,iBAAiB,CAqEnB"}

package/dist/better-auth/plugin/helpers/get-better-auth-schema.js

@@ -0,0 +1,75 @@
+import { getAuthTables } from "better-auth/db";
+import { baModelFieldKeysToFieldNames, baModelKey, defaults } from "../constants";
+import { set } from "../utils/set";
+import { getDefaultCollectionSlug } from "./get-collection-slug";
+/**
+ * A consistent BetterAuth schema generator.
+ *
+ * Differences from the original `getSchema` implementation in BetterAuth:
+ * 1. Keys in the returned object are always the **static table identifiers** coming from
+ *    `getAuthTables`, never the possibly-overridden `modelName`.  This guarantees that
+ *    subsequent look-ups remain stable even if the user renames collections.
+ * 2. Each schema entry now contains an explicit `modelName` property exposing the current
+ *    (potentially user-overridden) model name, while `fields` continue to be referenced by
+ *    their static BetterAuth field keys.
+ * 3. When converting fields, we store them under their original key (`actualFields[key] = field`)
+ *    instead of `field.fieldName || key` to avoid accidental renames.
+ *
+ * @param config - The BetterAuth options fed into `getAuthTables`.
+ * @returns A map keyed by static table keys, each value containing `{ modelName, fields, order }`.
+ */ export function getDefaultBetterAuthSchema(pluginOptions) {
+    const betterAuthOptions = pluginOptions.betterAuthOptions ?? {};
+    // We need to add the additional role field to the user schema here or else the built collections will not pick it up.
+    set(betterAuthOptions, `${baModelKey.user}.additionalFields.role`, {
+        type: "string",
+        defaultValue: pluginOptions.users?.defaultRole || defaults.userRole,
+        input: false
+    });
+    const tables = getAuthTables(betterAuthOptions);
+    const schema = {};
+    for (const modelKey of Object.keys(tables)){
+        const table = tables[modelKey];
+        // Resolve the canonical collection slug / model name for this key
+        const resolvedModelName = getDefaultCollectionSlug({
+            modelKey,
+            pluginOptions
+        });
+        const defaultFieldMap = baModelFieldKeysToFieldNames[modelKey] ?? {};
+        const actualFields = {};
+        Object.entries(table.fields).forEach(([fieldKey, fieldValue])=>{
+            // Build the field ensuring a fieldName exists
+            const newField = {
+                ...fieldValue,
+                fieldName: defaultFieldMap[fieldKey] ?? fieldKey
+            };
+            // Rewrite references to use the resolved modelName for the target table
+            if (fieldValue.references) {
+                const refModelKey = fieldValue.references.model;
+                const resolvedRefModelName = getDefaultCollectionSlug({
+                    modelKey: refModelKey,
+                    pluginOptions
+                });
+                newField.references = {
+                    model: resolvedRefModelName,
+                    field: fieldValue.references.field
+                };
+            }
+            actualFields[fieldKey] = newField;
+        });
+        if (schema[modelKey]) {
+            schema[modelKey].fields = {
+                ...schema[modelKey].fields,
+                ...actualFields
+            };
+            continue;
+        }
+        schema[modelKey] = {
+            modelName: resolvedModelName,
+            fields: actualFields,
+            order: table.order || Infinity
+        };
+    }
+    return schema;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/helpers/get-collection-slug.d.ts

@@ -0,0 +1,6 @@
+import type { PayloadAuthOptions } from "../types";
+export declare function getDefaultCollectionSlug({ pluginOptions, modelKey }: {
+    pluginOptions: PayloadAuthOptions;
+    modelKey: string;
+}): string;
+//# sourceMappingURL=get-collection-slug.d.ts.map

package/dist/better-auth/plugin/helpers/get-collection-slug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-collection-slug.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/get-collection-slug.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEnD,wBAAgB,wBAAwB,CAAC,EACvC,aAAa,EACb,QAAQ,EACT,EAAE;IACD,aAAa,EAAE,kBAAkB,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,MAAM,CAkBT"}

package/dist/better-auth/plugin/helpers/get-collection-slug.js

@@ -0,0 +1,20 @@
+import { baModelKeyToSlug, baseSlugs } from "../constants";
+export function getDefaultCollectionSlug({ pluginOptions, modelKey }) {
+    const baseSlug = baModelKeyToSlug[modelKey] ?? modelKey;
+    switch(modelKey){
+        case "user":
+            return pluginOptions.users?.slug ?? baseSlugs.users;
+        case "account":
+            return pluginOptions.accounts?.slug ?? baseSlugs.accounts;
+        case "session":
+            return pluginOptions.sessions?.slug ?? baseSlugs.sessions;
+        case "verification":
+            return pluginOptions.verifications?.slug ?? baseSlugs.verifications;
+        case "adminInvitation":
+            return pluginOptions.adminInvitations?.slug ?? baseSlugs.adminInvitations;
+        default:
+            return baseSlug;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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