payload-auth 1.6.0 → 1.6.1-canary.2

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

@@ -1 +1 @@
-{"version":3,"file":"get-collection.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/get-collection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAElE;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,aAAa,EACb,kBAAkB,EACnB,EAAE;IACD,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAA;IAC/C,kBAAkB,EAAE,MAAM,CAAA;CAC3B,GAAG,gBAAgB,CAcnB;AAED,UAAU,WAAY,SAAQ,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC;IAC/C,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,aAAa,CAAC,CAAA;CAC7D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,EAC7B,UAAU,EACV,kBAAkB,EACnB,EAAE;IACD,UAAU,EAAE,gBAAgB,CAAA;IAC5B,kBAAkB,EAAE,MAAM,CAAA;CAC3B,GAAG,WAAW,CAmBd;AAED,wBAAgB,uCAAuC,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAIjI"}
+{"version":3,"file":"get-collection.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/get-collection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAA;AAC9E,OAAO,EAAoB,KAAK,UAAU,EAAE,KAAK,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAElF,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE,QAAQ,EAAE,QAAQ,GAAG,gBAAgB,CAUrH;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gCAAgC,CAAC,CAAC,SAAS,QAAQ,EACjE,UAAU,EAAE,gBAAgB,EAC5B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,OAAO,CAAC,MAAM,oBAAoB,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,GACvD,MAAM,CAIR"}

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

@@ -1,62 +1,29 @@
-/**
- * Retrieves a collection from the collection map based on its Better Auth model key
- *
- * This function searches through the provided collection map to find a collection
- * that has been marked with a specific Better Auth model key in its custom properties.
- * It's used to map between Better Auth's internal model keys and Payload CMS collections.
- *
- * @param collectionMap - Map of all available collections
- * @param betterAuthModelKey - The Better Auth model key to search for
- * @returns The matched collection configuration
- * @throws {Error} If no collection with the specified Better Auth model key is found
- */ export function getMappedCollection({ collectionMap, betterAuthModelKey }) {
-    // Find the collection that has the matching betterAuthModelKey in its custom properties
-    const collection = Object.values(collectionMap).find((c)=>{
-        return c.custom?.betterAuthModelKey === betterAuthModelKey;
+import { flattenAllFields } from "payload";
+export function getCollectionByModelKey(collections, modelKey) {
+    const collection = Object.values(collections).find((c)=>{
+        return c.config?.custom?.betterAuthModelKey === modelKey;
     });
-    // Throw an error if no matching collection is found
     if (!collection) {
-        const error = new Error(`Collection with key ${betterAuthModelKey} not found`);
-        Error.captureStackTrace(error, getMappedCollection);
-        throw error;
+        throw new Error(`Collection with key ${modelKey} not found`);
     }
-    return collection;
+    return collection.config;
 }
 /**
- * Retrieves a field from a collection based on its Better Auth field key
+ * Retrieves the field name from a collection based on the field key
  *
- * This function searches through the fields of a provided collection to find a field
- * that has been marked with a specific Better Auth field key in its custom properties.
- * It's used to map between Better Auth's internal field keys and Payload CMS field configurations.
+ * This function searches through the fields of a collection to find a field
+ * that has a matching custom property betterAuthFieldKey.
  *
- * @param collection - The collection configuration to search within
- * @param betterAuthFieldKey - The Better Auth field key to search for
- * @returns The matched field configuration with a guaranteed name and non-UI type
- * @throws {Error} If no field with the specified Better Auth field key is found
- * @throws {Error} If the found field is a UI-only field type (tabs, row, collapsible)
- */ export function getMappedField({ collection, betterAuthFieldKey }) {
-    // Find the field that has the matching betterAuthFieldKey in its custom properties
-    const field = collection.fields.find((f)=>f.custom?.betterAuthFieldKey === betterAuthFieldKey);
-    // Throw an error if no matching field is found
-    if (!field) {
-        throw new Error(`Field with key ${betterAuthFieldKey} not found`);
-    }
-    // Filter out UI-based fields that don't have a name or aren't data fields
-    // These field types are used for layout purposes only and cannot store data
-    switch(field.type){
-        case 'tabs':
-        case 'row':
-        case 'collapsible':
-            throw new Error(`Field with key ${betterAuthFieldKey} is a UI-only field and cannot be used for data`);
-        default:
-            return field;
-    }
-}
-export function transformCollectionsToCollectionConfigs(collections) {
-    return Object.fromEntries(Object.entries(collections).map(([slug, collection])=>[
-            slug,
-            collection.config
-        ]));
+ * @param collection - The collection configuration to search through
+ * @param model - The model key of the collection (This is really just for type hinting)
+ * @param fieldKey - The key of the field to search for
+ * @returns The name of the field if found, otherwise the field key itself
+ */ export function getCollectionFieldNameByFieldKey(collection, model, fieldKey) {
+    const fields = flattenAllFields({
+        fields: collection.fields
+    });
+    console.log('fields', fields);
+    return fields.find((f)=>f.custom?.betterAuthFieldKey === fieldKey)?.name ?? fieldKey;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/helpers/prepare-session-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prepare-session-data.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/prepare-session-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,KAAK,EAAc,gBAAgB,EAAmB,MAAM,SAAS,CAAA;AAK5E,wBAAsB,WAAW,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,EAAE;IAAE,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAAC,cAAc,EAAE,gBAAgB,CAAA;CAAE;;;;;;;;yBAWjI;AAED,wBAAsB,cAAc,CAAC,EACnC,OAAO,EACP,iBAAiB,EAClB,EAAE;IACD,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACtC,iBAAiB,EAAE,gBAAgB,CAAA;CACpC;;;;;;;;;yBAiBA;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,EACvC,WAAW,EACX,eAAe,EACf,kBAAkB,EACnB,EAAE;IACD,WAAW,EAAE;QACX,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QACtC,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KACjC,CAAA;IACD,eAAe,EAAE,gBAAgB,CAAA;IACjC,kBAAkB,EAAE,gBAAgB,CAAA;CACrC;;;;;;;;;;;;;;;;;;;;UAYA"}
+{"version":3,"file":"prepare-session-data.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/prepare-session-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAG/C,wBAAsB,WAAW,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,EAAE;IAAE,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAAC,cAAc,EAAE,gBAAgB,CAAA;CAAE;;;;;;;;yBAWjI;AAED,wBAAsB,cAAc,CAAC,EACnC,OAAO,EACP,iBAAiB,EAClB,EAAE;IACD,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACtC,iBAAiB,EAAE,gBAAgB,CAAA;CACpC;;;;;;;;;yBAiBA;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,EACvC,WAAW,EACX,eAAe,EACf,kBAAkB,EACnB,EAAE;IACD,WAAW,EAAE;QACX,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QACtC,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KACjC,CAAA;IACD,eAAe,EAAE,gBAAgB,CAAA;IACjC,kBAAkB,EAAE,gBAAgB,CAAA;CACrC;;;;;;;;;;;;;;;;;;;;UAYA"}

package/dist/better-auth/plugin/helpers/prepare-session-data.js

@@ -46,4 +46,4 @@ export async function prepareSession({ session, sessionCollection }) {
     return newSessionData;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/helpers/sync-resolved-schema-with-collection-map.d.ts

@@ -0,0 +1,21 @@
+import type { CollectionConfig } from 'payload';
+import type { BetterAuthSchemas } from '../types';
+/**
+ * Syncs a BetterAuth `ResolvedSchema` object with the *actual* collection
+ * definitions created by this plugin.
+ *
+ * This must run **after** the first call to `buildCollections`, because only
+ * then do we know the user-overridden slugs / field names.  The algorithm is
+ * kept deliberately simple:
+ *
+ *  1. Build a `modelKey → newSlug` map from each collection's
+ *     `custom.betterAuthModelKey` property.
+ *  2. Update `schema.modelName` for all affected tables.
+ *  3. Rewrite `references.model` in *every* table field according to the new
+ *     slugs.  We do this in a dedicated pass so referencing tables no longer
+ *     depend on the original slugs.
+ *  4. Finally, iterate collections once more to apply any *field* renames via
+ *     the `custom.betterAuthFieldKey` property.
+ */
+export declare function syncResolvedSchemaWithCollectionMap(resolvedSchemas: BetterAuthSchemas, collectionMap: Record<string, CollectionConfig>): BetterAuthSchemas;
+//# sourceMappingURL=sync-resolved-schema-with-collection-map.d.ts.map

package/dist/better-auth/plugin/helpers/sync-resolved-schema-with-collection-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-resolved-schema-with-collection-map.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/sync-resolved-schema-with-collection-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAG/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAEjD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mCAAmC,CACjD,eAAe,EAAE,iBAAiB,EAClC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAC9C,iBAAiB,CAwDnB"}

package/dist/better-auth/plugin/helpers/sync-resolved-schema-with-collection-map.js

@@ -0,0 +1,62 @@
+/**
+ * Syncs a BetterAuth `ResolvedSchema` object with the *actual* collection
+ * definitions created by this plugin.
+ *
+ * This must run **after** the first call to `buildCollections`, because only
+ * then do we know the user-overridden slugs / field names.  The algorithm is
+ * kept deliberately simple:
+ *
+ *  1. Build a `modelKey → newSlug` map from each collection's
+ *     `custom.betterAuthModelKey` property.
+ *  2. Update `schema.modelName` for all affected tables.
+ *  3. Rewrite `references.model` in *every* table field according to the new
+ *     slugs.  We do this in a dedicated pass so referencing tables no longer
+ *     depend on the original slugs.
+ *  4. Finally, iterate collections once more to apply any *field* renames via
+ *     the `custom.betterAuthFieldKey` property.
+ */ export function syncResolvedSchemaWithCollectionMap(resolvedSchemas, collectionMap) {
+    const collections = Object.values(collectionMap);
+    // Helper to update references across the whole schema
+    const updateReferences = (oldSlug, newSlug)=>{
+        for (const schema of Object.values(resolvedSchemas)){
+            for (const fieldAttr of Object.values(schema.fields)){
+                const ref = fieldAttr.references;
+                if (ref?.model === oldSlug) {
+                    ref.model = newSlug;
+                }
+            }
+        }
+    };
+    for (const [modelKey, schema] of Object.entries(resolvedSchemas)){
+        // Find the collection corresponding to this BetterAuth model
+        const collection = collections.find((c)=>c.custom?.betterAuthModelKey === modelKey);
+        if (!collection) {
+            console.error(`Collection not found for model key: ${modelKey}`);
+            continue;
+        }
+        // ───── Sync slug ─────────────────────────────────────────────────────────
+        const oldSlug = schema.modelName;
+        const newSlug = collection.slug;
+        if (oldSlug !== newSlug) {
+            // First, rewrite *all* references that still point to the old slug
+            updateReferences(oldSlug, newSlug);
+            // Now store the new slug on the schema itself
+            schema.modelName = newSlug;
+        }
+        const collectionFields = Array.isArray(collection.fields) ? collection.fields : [];
+        for (const [fieldKey, schemaField] of Object.entries(schema.fields)){
+            const matchingField = collectionFields.find((f)=>f.custom?.betterAuthFieldKey === fieldKey);
+            if (!matchingField) {
+                console.error(`Field not found for key "${fieldKey}" in collection "${collection.slug}"`);
+                continue;
+            }
+            const newName = matchingField.name;
+            if (newName && schemaField.fieldName !== newName) {
+                schemaField.fieldName = newName;
+            }
+        }
+    }
+    return resolvedSchemas;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/index.d.ts

@@ -1,8 +1,12 @@
-import { type Config } from 'payload';
+import type { BetterAuthOptions } from 'better-auth/types';
+import { SanitizedConfig, type Config } from 'payload';
 import type { BetterAuthPluginOptions } from './types';
 export * from './helpers/index';
 export { getPayloadAuth } from './lib/get-payload-auth';
 export { sanitizeBetterAuthOptions } from './lib/sanitize-better-auth-options/index';
 export * from './types';
 export declare function betterAuthPlugin(pluginOptions: BetterAuthPluginOptions): (config: Config) => Config;
+export declare function withPayloadAuth({ payloadConfig }: {
+    payloadConfig: SanitizedConfig;
+}): BetterAuthOptions;
 //# sourceMappingURL=index.d.ts.map

package/dist/better-auth/plugin/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/better-auth/plugin/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2D,KAAK,MAAM,EAAc,MAAM,SAAS,CAAA;AAQ1G,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAA;AAItD,cAAc,iBAAiB,CAAA;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AACvD,OAAO,EAAE,yBAAyB,EAAE,MAAM,0CAA0C,CAAA;AACpF,cAAc,SAAS,CAAA;AAEvB,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,uBAAuB,IAC7D,QAAQ,MAAM,KAAG,MAAM,CA2IhC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/better-auth/plugin/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAC1D,OAAO,EAAc,eAAe,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAA;AAUlE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAA;AAGtD,cAAc,iBAAiB,CAAA;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AACvD,OAAO,EAAE,yBAAyB,EAAE,MAAM,0CAA0C,CAAA;AACpF,cAAc,SAAS,CAAA;AAwCvB,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,uBAAuB,IAC7D,QAAQ,MAAM,KAAG,MAAM,CA+DhC;AAED,wBAAgB,eAAe,CAAC,EAAE,aAAa,EAAE,EAAE;IAAE,aAAa,EAAE,eAAe,CAAA;CAAE,GAAG,iBAAiB,CAgBxG"}

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

@@ -1,14 +1,49 @@
-import { adminRoutes, baModelKey, baseSlugs, supportedBAPluginIds } from "./constants";
-import { checkPluginExists } from "./helpers/check-plugin-exists";
-import { buildCollectionMap } from "./lib/build-collections/index";
+import { getPayload } from "payload";
+import { payloadAdapter } from "payload-auth/better-auth/adapter";
+import { getDefaultBetterAuthSchema } from "./helpers/get-better-auth-schema";
+import { syncResolvedSchemaWithCollectionMap } from "./helpers/sync-resolved-schema-with-collection-map";
+import { applyDisabledDefaultAuthConfig } from "./lib/apply-disabled-default-auth-config";
+import { buildCollections } from "./lib/build-collections/index";
 import { initBetterAuth } from "./lib/init-better-auth";
 import { sanitizeBetterAuthOptions } from "./lib/sanitize-better-auth-options/index";
 import { setLoginMethods } from "./lib/set-login-methods";
-import { buildCollectionSchemaMap } from "./helpers/get-collection-schema-map";
+import { set } from "./utils/set";
 export * from "./helpers/index";
 export { getPayloadAuth } from "./lib/get-payload-auth";
 export { sanitizeBetterAuthOptions } from "./lib/sanitize-better-auth-options/index";
 export * from "./types";
+function buildBetterAuthData({ payloadConfig, pluginOptions }) {
+    pluginOptions = setLoginMethods({
+        pluginOptions
+    });
+    const defaultBetterAuthSchemas = getDefaultBetterAuthSchema(pluginOptions);
+    let collectionMap = buildCollections({
+        resolvedSchemas: defaultBetterAuthSchemas,
+        incomingCollections: payloadConfig.collections ?? [],
+        pluginOptions
+    });
+    const resolvedBetterAuthSchemas = syncResolvedSchemaWithCollectionMap(defaultBetterAuthSchemas, collectionMap);
+    // We need to build the collections a second time with the resolved schemas
+    // due to hooks, endpoints, useAsTitle, etc should relay on resolvedBetterAuthSchemas to get slugs
+    // if they are referencing to other collections then it self.
+    collectionMap = buildCollections({
+        resolvedSchemas: resolvedBetterAuthSchemas,
+        incomingCollections: payloadConfig.collections ?? [],
+        pluginOptions
+    });
+    const sanitizedBetterAuthOptions = sanitizeBetterAuthOptions({
+        config: payloadConfig,
+        pluginOptions,
+        resolvedSchemas: resolvedBetterAuthSchemas
+    });
+    pluginOptions.betterAuthOptions = sanitizedBetterAuthOptions;
+    return {
+        pluginOptions,
+        collectionMap,
+        resolvedBetterAuthSchemas,
+        sanitizedBetterAuthOptions
+    };
+}
 export function betterAuthPlugin(pluginOptions) {
     return (config)=>{
         if (pluginOptions.disabled) {
@@ -18,95 +53,19 @@ export function betterAuthPlugin(pluginOptions) {
             ...config.custom,
             hasBetterAuthPlugin: true
         };
-        pluginOptions = setLoginMethods({
-            pluginOptions
-        });
-        const collectionSchemaMap = buildCollectionSchemaMap(pluginOptions);
-        const sanitizedBetterAuthOptions = sanitizeBetterAuthOptions({
-            config,
-            pluginOptions,
-            collectionSchemaMap
-        });
-        pluginOptions.betterAuthOptions = sanitizedBetterAuthOptions;
-        // Build the collection map
-        const collectionMap = buildCollectionMap({
-            collectionSchemaMap,
-            incomingCollections: config.collections ?? [],
+        const { collectionMap, resolvedBetterAuthSchemas, sanitizedBetterAuthOptions } = buildBetterAuthData({
+            payloadConfig: config,
             pluginOptions
         });
-        // Set custom admin components if disableDefaultPayloadAuth is true
+        set(config, 'custom.betterAuth.config', sanitizedBetterAuthOptions);
+        // ---------------------- Finalize config -----------------
         if (pluginOptions.disableDefaultPayloadAuth) {
-            config.admin = {
-                ...config.admin,
-                components: {
-                    ...config.admin?.components,
-                    afterLogin: [
-                        {
-                            path: 'payload-auth/better-auth/plugin/rsc#RSCRedirect',
-                            serverProps: {
-                                redirectTo: `${config.routes?.admin === undefined ? '/admin' : config.routes.admin}${adminRoutes.adminLogin}`
-                            }
-                        },
-                        ...config.admin?.components?.afterLogin || []
-                    ],
-                    logout: {
-                        Button: {
-                            path: 'payload-auth/better-auth/plugin/client#LogoutButton'
-                        }
-                    },
-                    views: {
-                        ...config.admin?.components?.views,
-                        adminLogin: {
-                            path: adminRoutes.adminLogin,
-                            Component: {
-                                path: 'payload-auth/better-auth/plugin/rsc#AdminLogin',
-                                serverProps: {
-                                    pluginOptions: pluginOptions,
-                                    adminInvitationsSlug: collectionMap[baseSlugs.adminInvitations].slug
-                                }
-                            }
-                        },
-                        adminSignup: {
-                            path: adminRoutes.adminSignup,
-                            Component: {
-                                path: 'payload-auth/better-auth/plugin/rsc#AdminSignup',
-                                serverProps: {
-                                    pluginOptions: pluginOptions,
-                                    adminInvitationsSlug: collectionMap[baseSlugs.adminInvitations].slug
-                                }
-                            }
-                        },
-                        forgotPassword: {
-                            path: adminRoutes.forgotPassword,
-                            Component: {
-                                path: 'payload-auth/better-auth/plugin/rsc#ForgotPassword'
-                            }
-                        },
-                        resetPassword: {
-                            path: adminRoutes.resetPassword,
-                            Component: {
-                                path: 'payload-auth/better-auth/plugin/rsc#ResetPassword'
-                            }
-                        },
-                        ...checkPluginExists(pluginOptions.betterAuthOptions ?? {}, supportedBAPluginIds.twoFactor) && {
-                            twoFactorVerify: {
-                                path: adminRoutes.twoFactorVerify,
-                                Component: {
-                                    path: 'payload-auth/better-auth/plugin/rsc#TwoFactorVerify',
-                                    serverProps: {
-                                        pluginOptions: pluginOptions,
-                                        verificationsSlug: collectionSchemaMap[baModelKey.verification].collectionSlug
-                                    }
-                                }
-                            }
-                        }
-                    }
-                },
-                routes: {
-                    ...config.admin?.routes,
-                    login: adminRoutes.loginRedirect
-                }
-            };
+            applyDisabledDefaultAuthConfig({
+                config,
+                pluginOptions,
+                collectionMap,
+                resolvedBetterAuthSchemas
+            });
         }
         config.collections = config.collections ?? [];
         config.collections = Object.values(collectionMap);
@@ -143,5 +102,21 @@ export function betterAuthPlugin(pluginOptions) {
         return config;
     };
 }
+export function withPayloadAuth({ payloadConfig }) {
+    const betterAuthConfig = payloadConfig.custom.betterAuth.config;
+    if (!betterAuthConfig) {
+        throw new Error('BetterAuth config not found. Not set payloadConfig.custom.betterAuth.config');
+    }
+    const optionsWithAdapter = {
+        ...betterAuthConfig,
+        database: payloadAdapter({
+            payloadClient: async ()=>await getPayload({
+                    config: payloadConfig
+                }),
+            idType: payloadConfig.db.defaultIDType
+        })
+    };
+    return optionsWithAdapter;
+}
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/better-auth/plugin/index.ts"],"sourcesContent":["import { flattenAllFields, FlattenedField, type CollectionConfig, type Config, type Field } from 'payload'\nimport { adminRoutes, baModelFieldKeys, baModelKey, baModelKeyToSlug, baseSlugs, supportedBAPluginIds } from './constants'\nimport { checkPluginExists } from './helpers/check-plugin-exists'\nimport { getMappedCollection } from './helpers/get-collection'\nimport { buildCollectionMap } from './lib/build-collections/index'\nimport { initBetterAuth } from './lib/init-better-auth'\nimport { sanitizeBetterAuthOptions } from './lib/sanitize-better-auth-options/index'\nimport { setLoginMethods } from './lib/set-login-methods'\nimport type { BetterAuthPluginOptions } from './types'\nimport { getDeafultCollectionSlug } from './helpers/get-collection-slug'\nimport { buildCollectionSchemaMap, getDefaultCollectionSchemaMap } from './helpers/get-collection-schema-map'\n\nexport * from './helpers/index'\nexport { getPayloadAuth } from './lib/get-payload-auth'\nexport { sanitizeBetterAuthOptions } from './lib/sanitize-better-auth-options/index'\nexport * from './types'\n\nexport function betterAuthPlugin(pluginOptions: BetterAuthPluginOptions) {\n  return (config: Config): Config => {\n    if (pluginOptions.disabled) {\n      return config\n    }\n\n    config.custom = {\n      ...config.custom,\n      hasBetterAuthPlugin: true\n    }\n\n    pluginOptions = setLoginMethods({ pluginOptions })\n\n    const collectionSchemaMap = buildCollectionSchemaMap(pluginOptions)\n    const sanitizedBetterAuthOptions = sanitizeBetterAuthOptions({\n      config,\n      pluginOptions,\n      collectionSchemaMap\n    })\n\n    pluginOptions.betterAuthOptions = sanitizedBetterAuthOptions\n\n    // Build the collection map\n    const collectionMap = buildCollectionMap({\n      collectionSchemaMap,\n      incomingCollections: config.collections ?? [],\n      pluginOptions\n    })\n\n    // Set custom admin components if disableDefaultPayloadAuth is true\n    if (pluginOptions.disableDefaultPayloadAuth) {\n      config.admin = {\n        ...config.admin,\n        components: {\n          ...config.admin?.components,\n          afterLogin: [\n            {\n              path: 'payload-auth/better-auth/plugin/rsc#RSCRedirect',\n              serverProps: {\n                redirectTo: `${config.routes?.admin === undefined ? '/admin' : config.routes.admin}${adminRoutes.adminLogin}`\n              }\n            },\n            ...(config.admin?.components?.afterLogin || [])\n          ],\n          logout: {\n            Button: {\n              path: 'payload-auth/better-auth/plugin/client#LogoutButton'\n            }\n          },\n          views: {\n            ...config.admin?.components?.views,\n            adminLogin: {\n              path: adminRoutes.adminLogin,\n              Component: {\n                path: 'payload-auth/better-auth/plugin/rsc#AdminLogin',\n                serverProps: {\n                  pluginOptions: pluginOptions,\n                  adminInvitationsSlug: collectionMap[baseSlugs.adminInvitations].slug\n                }\n              }\n            },\n            adminSignup: {\n              path: adminRoutes.adminSignup,\n              Component: {\n                path: 'payload-auth/better-auth/plugin/rsc#AdminSignup',\n                serverProps: {\n                  pluginOptions: pluginOptions,\n                  adminInvitationsSlug: collectionMap[baseSlugs.adminInvitations].slug\n                }\n              }\n            },\n            forgotPassword: {\n              path: adminRoutes.forgotPassword,\n              Component: {\n                path: 'payload-auth/better-auth/plugin/rsc#ForgotPassword'\n              }\n            },\n            resetPassword: {\n              path: adminRoutes.resetPassword,\n              Component: {\n                path: 'payload-auth/better-auth/plugin/rsc#ResetPassword'\n              }\n            },\n            ...(checkPluginExists(pluginOptions.betterAuthOptions ?? {}, supportedBAPluginIds.twoFactor) && {\n              twoFactorVerify: {\n                path: adminRoutes.twoFactorVerify,\n                Component: {\n                  path: 'payload-auth/better-auth/plugin/rsc#TwoFactorVerify',\n                  serverProps: {\n                    pluginOptions: pluginOptions,\n                    verificationsSlug: collectionSchemaMap[baModelKey.verification].collectionSlug\n                  }\n                }\n              }\n            })\n          }\n        },\n        routes: {\n          ...config.admin?.routes,\n          login: adminRoutes.loginRedirect\n        }\n      }\n    }\n\n    config.collections = config.collections ?? []\n    config.collections = Object.values(collectionMap)\n\n    const incomingOnInit = config.onInit\n\n    config.onInit = async (payload) => {\n      try {\n        // Execute any existing onInit functions first\n        if (incomingOnInit) {\n          await incomingOnInit(payload)\n        }\n\n        // Initialize and set the betterAuth instance\n        const auth = initBetterAuth<NonNullable<typeof sanitizedBetterAuthOptions.plugins>>({\n          payload,\n          idType: payload.db.defaultIDType,\n          options: {\n            ...sanitizedBetterAuthOptions,\n            enableDebugLogs: pluginOptions.debug?.enableDebugLogs ?? false,\n            plugins: [...(sanitizedBetterAuthOptions.plugins ?? [])]\n          }\n        })\n\n        // Type-safe extension of payload with betterAuth\n        Object.defineProperty(payload, 'betterAuth', {\n          value: auth,\n          writable: false,\n          configurable: false\n        })\n      } catch (error) {\n        console.error('Failed to initialize BetterAuth:', error)\n        throw error\n      }\n    }\n    return config\n  }\n}\n"],"names":["adminRoutes","baModelKey","baseSlugs","supportedBAPluginIds","checkPluginExists","buildCollectionMap","initBetterAuth","sanitizeBetterAuthOptions","setLoginMethods","buildCollectionSchemaMap","getPayloadAuth","betterAuthPlugin","pluginOptions","config","disabled","custom","hasBetterAuthPlugin","collectionSchemaMap","sanitizedBetterAuthOptions","betterAuthOptions","collectionMap","incomingCollections","collections","disableDefaultPayloadAuth","admin","components","afterLogin","path","serverProps","redirectTo","routes","undefined","adminLogin","logout","Button","views","Component","adminInvitationsSlug","adminInvitations","slug","adminSignup","forgotPassword","resetPassword","twoFactor","twoFactorVerify","verificationsSlug","verification","collectionSlug","login","loginRedirect","Object","values","incomingOnInit","onInit","payload","auth","idType","db","defaultIDType","options","enableDebugLogs","debug","plugins","defineProperty","value","writable","configurable","error","console"],"mappings":"AACA,SAASA,WAAW,EAAoBC,UAAU,EAAoBC,SAAS,EAAEC,oBAAoB,QAAQ,cAAa;AAC1H,SAASC,iBAAiB,QAAQ,gCAA+B;AAEjE,SAASC,kBAAkB,QAAQ,gCAA+B;AAClE,SAASC,cAAc,QAAQ,yBAAwB;AACvD,SAASC,yBAAyB,QAAQ,2CAA0C;AACpF,SAASC,eAAe,QAAQ,0BAAyB;AAGzD,SAASC,wBAAwB,QAAuC,sCAAqC;AAE7G,cAAc,kBAAiB;AAC/B,SAASC,cAAc,QAAQ,yBAAwB;AACvD,SAASH,yBAAyB,QAAQ,2CAA0C;AACpF,cAAc,UAAS;AAEvB,OAAO,SAASI,iBAAiBC,aAAsC;IACrE,OAAO,CAACC;QACN,IAAID,cAAcE,QAAQ,EAAE;YAC1B,OAAOD;QACT;QAEAA,OAAOE,MAAM,GAAG;YACd,GAAGF,OAAOE,MAAM;YAChBC,qBAAqB;QACvB;QAEAJ,gBAAgBJ,gBAAgB;YAAEI;QAAc;QAEhD,MAAMK,sBAAsBR,yBAAyBG;QACrD,MAAMM,6BAA6BX,0BAA0B;YAC3DM;YACAD;YACAK;QACF;QAEAL,cAAcO,iBAAiB,GAAGD;QAElC,2BAA2B;QAC3B,MAAME,gBAAgBf,mBAAmB;YACvCY;YACAI,qBAAqBR,OAAOS,WAAW,IAAI,EAAE;YAC7CV;QACF;QAEA,mEAAmE;QACnE,IAAIA,cAAcW,yBAAyB,EAAE;YAC3CV,OAAOW,KAAK,GAAG;gBACb,GAAGX,OAAOW,KAAK;gBACfC,YAAY;oBACV,GAAGZ,OAAOW,KAAK,EAAEC,UAAU;oBAC3BC,YAAY;wBACV;4BACEC,MAAM;4BACNC,aAAa;gCACXC,YAAY,GAAGhB,OAAOiB,MAAM,EAAEN,UAAUO,YAAY,WAAWlB,OAAOiB,MAAM,CAACN,KAAK,GAAGxB,YAAYgC,UAAU,EAAE;4BAC/G;wBACF;2BACInB,OAAOW,KAAK,EAAEC,YAAYC,cAAc,EAAE;qBAC/C;oBACDO,QAAQ;wBACNC,QAAQ;4BACNP,MAAM;wBACR;oBACF;oBACAQ,OAAO;wBACL,GAAGtB,OAAOW,KAAK,EAAEC,YAAYU,KAAK;wBAClCH,YAAY;4BACVL,MAAM3B,YAAYgC,UAAU;4BAC5BI,WAAW;gCACTT,MAAM;gCACNC,aAAa;oCACXhB,eAAeA;oCACfyB,sBAAsBjB,aAAa,CAAClB,UAAUoC,gBAAgB,CAAC,CAACC,IAAI;gCACtE;4BACF;wBACF;wBACAC,aAAa;4BACXb,MAAM3B,YAAYwC,WAAW;4BAC7BJ,WAAW;gCACTT,MAAM;gCACNC,aAAa;oCACXhB,eAAeA;oCACfyB,sBAAsBjB,aAAa,CAAClB,UAAUoC,gBAAgB,CAAC,CAACC,IAAI;gCACtE;4BACF;wBACF;wBACAE,gBAAgB;4BACdd,MAAM3B,YAAYyC,cAAc;4BAChCL,WAAW;gCACTT,MAAM;4BACR;wBACF;wBACAe,eAAe;4BACbf,MAAM3B,YAAY0C,aAAa;4BAC/BN,WAAW;gCACTT,MAAM;4BACR;wBACF;wBACA,GAAIvB,kBAAkBQ,cAAcO,iBAAiB,IAAI,CAAC,GAAGhB,qBAAqBwC,SAAS,KAAK;4BAC9FC,iBAAiB;gCACfjB,MAAM3B,YAAY4C,eAAe;gCACjCR,WAAW;oCACTT,MAAM;oCACNC,aAAa;wCACXhB,eAAeA;wCACfiC,mBAAmB5B,mBAAmB,CAAChB,WAAW6C,YAAY,CAAC,CAACC,cAAc;oCAChF;gCACF;4BACF;wBACF,CAAC;oBACH;gBACF;gBACAjB,QAAQ;oBACN,GAAGjB,OAAOW,KAAK,EAAEM,MAAM;oBACvBkB,OAAOhD,YAAYiD,aAAa;gBAClC;YACF;QACF;QAEApC,OAAOS,WAAW,GAAGT,OAAOS,WAAW,IAAI,EAAE;QAC7CT,OAAOS,WAAW,GAAG4B,OAAOC,MAAM,CAAC/B;QAEnC,MAAMgC,iBAAiBvC,OAAOwC,MAAM;QAEpCxC,OAAOwC,MAAM,GAAG,OAAOC;YACrB,IAAI;gBACF,8CAA8C;gBAC9C,IAAIF,gBAAgB;oBAClB,MAAMA,eAAeE;gBACvB;gBAEA,6CAA6C;gBAC7C,MAAMC,OAAOjD,eAAuE;oBAClFgD;oBACAE,QAAQF,QAAQG,EAAE,CAACC,aAAa;oBAChCC,SAAS;wBACP,GAAGzC,0BAA0B;wBAC7B0C,iBAAiBhD,cAAciD,KAAK,EAAED,mBAAmB;wBACzDE,SAAS;+BAAK5C,2BAA2B4C,OAAO,IAAI,EAAE;yBAAE;oBAC1D;gBACF;gBAEA,iDAAiD;gBACjDZ,OAAOa,cAAc,CAACT,SAAS,cAAc;oBAC3CU,OAAOT;oBACPU,UAAU;oBACVC,cAAc;gBAChB;YACF,EAAE,OAAOC,OAAO;gBACdC,QAAQD,KAAK,CAAC,oCAAoCA;gBAClD,MAAMA;YACR;QACF;QACA,OAAOtD;IACT;AACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/better-auth/plugin/index.ts"],"sourcesContent":["import type { BetterAuthOptions } from 'better-auth/types'\nimport { getPayload, SanitizedConfig, type Config } from 'payload'\nimport { payloadAdapter } from 'payload-auth/better-auth/adapter'\nimport { PayloadAdapterParams } from '../types'\nimport { getDefaultBetterAuthSchema } from './helpers/get-better-auth-schema'\nimport { syncResolvedSchemaWithCollectionMap } from './helpers/sync-resolved-schema-with-collection-map'\nimport { applyDisabledDefaultAuthConfig } from './lib/apply-disabled-default-auth-config'\nimport { buildCollections } from './lib/build-collections/index'\nimport { initBetterAuth } from './lib/init-better-auth'\nimport { sanitizeBetterAuthOptions } from './lib/sanitize-better-auth-options/index'\nimport { setLoginMethods } from './lib/set-login-methods'\nimport type { BetterAuthPluginOptions } from './types'\nimport { set } from './utils/set'\n\nexport * from './helpers/index'\nexport { getPayloadAuth } from './lib/get-payload-auth'\nexport { sanitizeBetterAuthOptions } from './lib/sanitize-better-auth-options/index'\nexport * from './types'\n\nfunction buildBetterAuthData({ payloadConfig, pluginOptions }: { payloadConfig: SanitizedConfig; pluginOptions: BetterAuthPluginOptions }) {\n  pluginOptions = setLoginMethods({ pluginOptions })\n\n  const defaultBetterAuthSchemas = getDefaultBetterAuthSchema(pluginOptions)\n\n  let collectionMap = buildCollections({\n    resolvedSchemas: defaultBetterAuthSchemas,\n    incomingCollections: payloadConfig.collections ?? [],\n    pluginOptions\n  })\n\n  const resolvedBetterAuthSchemas = syncResolvedSchemaWithCollectionMap(defaultBetterAuthSchemas, collectionMap)\n\n  // We need to build the collections a second time with the resolved schemas\n  // due to hooks, endpoints, useAsTitle, etc should relay on resolvedBetterAuthSchemas to get slugs\n  // if they are referencing to other collections then it self.\n  collectionMap = buildCollections({\n    resolvedSchemas: resolvedBetterAuthSchemas,\n    incomingCollections: payloadConfig.collections ?? [],\n    pluginOptions\n  })\n\n  const sanitizedBetterAuthOptions = sanitizeBetterAuthOptions({\n    config: payloadConfig,\n    pluginOptions,\n    resolvedSchemas: resolvedBetterAuthSchemas\n  })\n\n  pluginOptions.betterAuthOptions = sanitizedBetterAuthOptions\n\n  return {\n    pluginOptions,\n    collectionMap,\n    resolvedBetterAuthSchemas,\n    sanitizedBetterAuthOptions\n  }\n}\n\nexport function betterAuthPlugin(pluginOptions: BetterAuthPluginOptions) {\n  return (config: Config): Config => {\n    if (pluginOptions.disabled) {\n      return config\n    }\n\n    config.custom = {\n      ...config.custom,\n      hasBetterAuthPlugin: true\n    }\n\n    const { collectionMap, resolvedBetterAuthSchemas, sanitizedBetterAuthOptions } = buildBetterAuthData({\n      payloadConfig: config as SanitizedConfig,\n      pluginOptions\n    })\n\n    set(config, 'custom.betterAuth.config', sanitizedBetterAuthOptions)\n\n    // ---------------------- Finalize config -----------------\n    if (pluginOptions.disableDefaultPayloadAuth) {\n      applyDisabledDefaultAuthConfig({\n        config,\n        pluginOptions,\n        collectionMap,\n        resolvedBetterAuthSchemas\n      })\n    }\n\n    config.collections = config.collections ?? []\n    config.collections = Object.values(collectionMap)\n\n    const incomingOnInit = config.onInit\n\n    config.onInit = async (payload) => {\n      try {\n        // Execute any existing onInit functions first\n        if (incomingOnInit) {\n          await incomingOnInit(payload)\n        }\n\n        // Initialize and set the betterAuth instance\n        const auth = initBetterAuth<NonNullable<typeof sanitizedBetterAuthOptions.plugins>>({\n          payload,\n          idType: payload.db.defaultIDType,\n          options: {\n            ...sanitizedBetterAuthOptions,\n            enableDebugLogs: pluginOptions.debug?.enableDebugLogs ?? false,\n            plugins: [...(sanitizedBetterAuthOptions.plugins ?? [])]\n          }\n        })\n\n        // Type-safe extension of payload with betterAuth\n        Object.defineProperty(payload, 'betterAuth', {\n          value: auth,\n          writable: false,\n          configurable: false\n        })\n      } catch (error) {\n        console.error('Failed to initialize BetterAuth:', error)\n        throw error\n      }\n    }\n    return config\n  }\n}\n\nexport function withPayloadAuth({ payloadConfig }: { payloadConfig: SanitizedConfig }): BetterAuthOptions {\n  const betterAuthConfig = payloadConfig.custom.betterAuth.config as BetterAuthOptions\n\n  if (!betterAuthConfig) {\n    throw new Error('BetterAuth config not found. Not set payloadConfig.custom.betterAuth.config')\n  }\n\n  const optionsWithAdapter: BetterAuthOptions = {\n    ...betterAuthConfig,\n    database: payloadAdapter({\n      payloadClient: async () => await getPayload({ config: payloadConfig }),\n      idType: payloadConfig.db.defaultIDType\n    })\n  }\n\n  return optionsWithAdapter\n}\n"],"names":["getPayload","payloadAdapter","getDefaultBetterAuthSchema","syncResolvedSchemaWithCollectionMap","applyDisabledDefaultAuthConfig","buildCollections","initBetterAuth","sanitizeBetterAuthOptions","setLoginMethods","set","getPayloadAuth","buildBetterAuthData","payloadConfig","pluginOptions","defaultBetterAuthSchemas","collectionMap","resolvedSchemas","incomingCollections","collections","resolvedBetterAuthSchemas","sanitizedBetterAuthOptions","config","betterAuthOptions","betterAuthPlugin","disabled","custom","hasBetterAuthPlugin","disableDefaultPayloadAuth","Object","values","incomingOnInit","onInit","payload","auth","idType","db","defaultIDType","options","enableDebugLogs","debug","plugins","defineProperty","value","writable","configurable","error","console","withPayloadAuth","betterAuthConfig","betterAuth","Error","optionsWithAdapter","database","payloadClient"],"mappings":"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"}

package/dist/better-auth/plugin/lib/apply-disabled-default-auth-config.d.ts

@@ -0,0 +1,13 @@
+import type { BetterAuthPluginOptions, BetterAuthSchemas } from '../types';
+import type { Config, CollectionConfig } from 'payload';
+/**
+ * Applies all admin-related overrides when `disableDefaultPayloadAuth` is `true`.
+ * Mutates the provided Payload config in-place.
+ */
+export declare function applyDisabledDefaultAuthConfig({ config, pluginOptions, collectionMap, resolvedBetterAuthSchemas }: {
+    config: Config;
+    pluginOptions: BetterAuthPluginOptions;
+    collectionMap: Record<string, CollectionConfig>;
+    resolvedBetterAuthSchemas: BetterAuthSchemas;
+}): void;
+//# sourceMappingURL=apply-disabled-default-auth-config.d.ts.map

package/dist/better-auth/plugin/lib/apply-disabled-default-auth-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-disabled-default-auth-config.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/lib/apply-disabled-default-auth-config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC1E,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAEvD;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,EAC7C,MAAM,EACN,aAAa,EACb,aAAa,EACb,yBAAyB,EAC1B,EAAE;IACD,MAAM,EAAE,MAAM,CAAA;IACd,aAAa,EAAE,uBAAuB,CAAA;IACtC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAA;IAC/C,yBAAyB,EAAE,iBAAiB,CAAA;CAC7C,GAAG,IAAI,CAwEP"}

package/dist/better-auth/plugin/lib/apply-disabled-default-auth-config.js

@@ -0,0 +1,80 @@
+import { adminRoutes, baModelKey, baseSlugs, supportedBAPluginIds } from "../constants";
+import { checkPluginExists } from "../helpers/check-plugin-exists";
+/**
+ * Applies all admin-related overrides when `disableDefaultPayloadAuth` is `true`.
+ * Mutates the provided Payload config in-place.
+ */ export function applyDisabledDefaultAuthConfig({ config, pluginOptions, collectionMap, resolvedBetterAuthSchemas }) {
+    config.admin = {
+        ...config.admin,
+        components: {
+            ...config.admin?.components,
+            afterLogin: [
+                {
+                    path: 'payload-auth/better-auth/plugin/rsc#RSCRedirect',
+                    serverProps: {
+                        redirectTo: `${config.routes?.admin === undefined ? '/admin' : config.routes.admin}${adminRoutes.adminLogin}`
+                    }
+                },
+                ...config.admin?.components?.afterLogin || []
+            ],
+            logout: {
+                Button: {
+                    path: 'payload-auth/better-auth/plugin/client#LogoutButton'
+                }
+            },
+            views: {
+                ...config.admin?.components?.views,
+                adminLogin: {
+                    path: adminRoutes.adminLogin,
+                    Component: {
+                        path: 'payload-auth/better-auth/plugin/rsc#AdminLogin',
+                        serverProps: {
+                            pluginOptions: pluginOptions,
+                            adminInvitationsSlug: collectionMap[baseSlugs.adminInvitations].slug
+                        }
+                    }
+                },
+                adminSignup: {
+                    path: adminRoutes.adminSignup,
+                    Component: {
+                        path: 'payload-auth/better-auth/plugin/rsc#AdminSignup',
+                        serverProps: {
+                            pluginOptions: pluginOptions,
+                            adminInvitationsSlug: collectionMap[baseSlugs.adminInvitations].slug
+                        }
+                    }
+                },
+                forgotPassword: {
+                    path: adminRoutes.forgotPassword,
+                    Component: {
+                        path: 'payload-auth/better-auth/plugin/rsc#ForgotPassword'
+                    }
+                },
+                resetPassword: {
+                    path: adminRoutes.resetPassword,
+                    Component: {
+                        path: 'payload-auth/better-auth/plugin/rsc#ResetPassword'
+                    }
+                },
+                ...checkPluginExists(pluginOptions.betterAuthOptions ?? {}, supportedBAPluginIds.twoFactor) && {
+                    twoFactorVerify: {
+                        path: adminRoutes.twoFactorVerify,
+                        Component: {
+                            path: 'payload-auth/better-auth/plugin/rsc#TwoFactorVerify',
+                            serverProps: {
+                                pluginOptions: pluginOptions,
+                                verificationsSlug: resolvedBetterAuthSchemas[baModelKey.verification].modelName
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        routes: {
+            ...config.admin?.routes,
+            login: adminRoutes.loginRedirect
+        }
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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