@delmaredigital/payload-better-auth 0.3.6 → 0.3.8

package/README.md

@@ -209,7 +209,7 @@ export default buildConfig({
 })
 ```
 
-> **⚠️ Important:** Do NOT add a custom `beforeLogin` component to your admin config. The Better Auth plugin automatically injects its own login page, logout button, and redirect handling.
+> **⚠️ Note:** The plugin automatically injects its own login page, logout button, and redirect handling. Don't add a custom `beforeLogin` in Payload's `admin.components` directly - use the plugin's options instead (see [Customization](#customization) for `disableLoginView`, `loginViewComponent`, etc.).
 
 ### Step 4: Client-Side Auth
 
@@ -228,12 +228,29 @@ export const { useSession, signIn, signUp, signOut, twoFactor, passkey } = authC
 
 **Note:** `createPayloadAuthClient()` automatically uses `window.location.origin` as the base URL, so it works seamlessly across local dev, Vercel previews, and production without any configuration.
 
-For full control, you can also use the raw `createAuthClient` from Better Auth:
+**Adding custom plugins (e.g., Stripe):**
+
+For custom plugins with full TypeScript support, use `createAuthClient` with `payloadAuthPlugins`:
 
 ```ts
-import { createAuthClient } from '@delmaredigital/payload-better-auth/client'
+// src/lib/auth/client.ts
+'use client'
+
+import { createAuthClient, payloadAuthPlugins } from '@delmaredigital/payload-better-auth/client'
+import { stripeClient } from '@better-auth/stripe/client'
+
+// Spread payloadAuthPlugins to include defaults (twoFactor, apiKey, passkey)
+// Then add your custom plugins - full type safety!
+export const authClient = createAuthClient({
+  plugins: [...payloadAuthPlugins, stripeClient({ subscription: true })],
+})
+
+// authClient.subscription is fully typed
+export const { useSession, signIn, signUp, signOut, twoFactor, passkey, subscription } = authClient
 ```
 
+This approach uses Better Auth's native `createAuthClient` with our default plugins, giving you full type inference for any custom plugins you add.
+
 ### Step 5: Server-Side Session Access
 
 ```ts
@@ -350,12 +367,23 @@ betterAuthCollections({
 | `betterAuthOptions` | `BetterAuthOptions` | Your Better Auth options |
 | `skipCollections` | `string[]` | Collections to skip generating (default: `['user']`) |
 | `adminGroup` | `string` | Admin panel group name (default: `'Auth'`) |
-| `access` | `CollectionConfig['access']` | Custom access control for generated collections |
+| `access` | `CollectionConfig['access']` | Custom access control for generated collections. **Note**: Replaces default access entirely (see caution below). |
 | `usePlural` | `boolean` | Pluralize collection slugs (default: `true`) |
 | `configureSaveToJWT` | `boolean` | Auto-configure `saveToJWT` for session-critical fields (default: `true`) |
 | `firstUserAdmin` | `boolean \| FirstUserAdminOptions` | Make first registered user an admin (default: `true`) |
 | `customizeCollection` | `(modelKey, collection) => CollectionConfig` | Customize generated collections |
 
+> **⚠️ Caution on Custom Access:**
+> When providing the `access` option, it **completely replaces** the default access object for all auto-generated collections. It does not merge with or override individual properties.
+>
+> By default, the plugin sets:
+> - `read`: `isAdmin()`
+> - `delete`: `isAdmin()`
+> - `create`: `() => false` (Manual creation disabled - Better Auth manages these)
+> - `update`: `() => false` (Manual update disabled - Better Auth manages these)
+> 
+> You must explicitly handle all access types to ensure your collections remain secure and functional.
+
 **First User Admin:**
 
 By default, the first user to register is automatically assigned the admin role. This provides a better out-of-the-box experience - no need to manually update the database to create your first admin.
@@ -428,7 +456,7 @@ createBetterAuthPlugin({
 | `admin.login.afterLoginPath` | `string` | `'/admin'` | Redirect path after successful login |
 | `admin.login.requiredRole` | `string \| string[] \| null` | `'admin'` | Required role(s) for admin access. Array = any role matches (unless `requireAllRoles`). Set to `null` to disable. |
 | `admin.login.requireAllRoles` | `boolean` | `false` | When `requiredRole` is an array, require ALL roles (true) or ANY role (false). |
-| `admin.login.enablePasskey` | `boolean` | `false` | Enable passkey (WebAuthn) sign-in option |
+| `admin.login.enablePasskey` | `boolean \| 'auto'` | `false` | Enable passkey (WebAuthn) sign-in option. `'auto'` detects if passkey plugin is available. |
 | `admin.login.enableSignUp` | `boolean \| 'auto'` | `'auto'` | Enable user registration. `'auto'` detects if sign-up endpoint is available. |
 | `admin.login.defaultSignUpRole` | `string` | `'user'` | Default role assigned to new users during registration |
 | `admin.login.enableForgotPassword` | `boolean \| 'auto'` | `'auto'` | Enable forgot password link. `'auto'` detects if endpoint is available. |
@@ -679,6 +707,17 @@ This is useful when you need:
 - Integration with external identity providers
 - Custom branding or UI requirements
 
+**Frontend Login (outside admin panel):**
+
+For user-facing login pages (not the Payload admin), you don't need to configure anything in the plugin. Just use the auth client directly in your own React components:
+
+```tsx
+import { authClient } from '@/lib/auth/client'
+
+// Use authClient.signIn.email(), authClient.signUp.email(), etc.
+// See "Handling 2FA in Custom Login Forms" section below for a complete example
+```
+
 ### Custom Admin Components
 
 Override specific admin components while keeping others auto-injected:
@@ -1152,15 +1191,18 @@ export const auth = betterAuth({
 
 ### User Registration
 
-The `LoginView` includes an optional "Create account" link that automatically detects if user registration is available. When enabled, users can register directly from the login page.
+The `LoginView` **automatically detects** if user registration is available by checking Better Auth's sign-up endpoint. If your Better Auth config has `emailAndPassword.enabled: true` (and not `disableSignUp: true`), the "Create account" link appears automatically.
 
-**Configuration:**
+**No configuration needed** for most cases - it just works based on your Better Auth settings.
+
+**Optional overrides** (only if you need to force show/hide):
 ```typescript
 createBetterAuthPlugin({
   createAuth,
   admin: {
     login: {
-      enableSignUp: true,       // or 'auto' (default) to detect availability
+      // These options override auto-detection (usually not needed)
+      enableSignUp: 'auto',      // 'auto' (default) | true | false
       defaultSignUpRole: 'user', // Role assigned to new users (default: 'user')
     },
   },
@@ -1168,22 +1210,28 @@ createBetterAuthPlugin({
 ```
 
 **Notes:**
+- `'auto'` (default): Detects availability from Better Auth's sign-up endpoint
+- `true`: Always show registration (even if Better Auth returns 404)
+- `false`: Never show registration
 - New users are assigned `defaultSignUpRole` (default: `'user'`)
 - If email verification is required, users see a success message to check their email
 - Role-based access control still applies - users without `requiredRole` see "Access Denied"
 
 ### Password Reset Flow
 
-The `LoginView` includes an inline "Forgot password?" link that automatically detects if password reset is available. When clicked, users can request a reset link without leaving the login page.
+The `LoginView` **automatically detects** if password reset is available by checking Better Auth's reset endpoint. The "Forgot password?" link appears automatically when available.
 
-**Configuration:**
+**No configuration needed** for most cases - it just works based on your Better Auth settings.
+
+**Optional overrides** (only if you need to force show/hide or use a custom URL):
 ```typescript
 createBetterAuthPlugin({
   createAuth,
   admin: {
     login: {
-      enableForgotPassword: true,  // or 'auto' (default) to detect availability
-      resetPasswordUrl: '/custom-reset',  // Optional: redirect to custom page instead
+      // These options override auto-detection (usually not needed)
+      enableForgotPassword: 'auto',       // 'auto' (default) | true | false
+      resetPasswordUrl: '/custom-reset',  // Optional: redirect to custom page instead of inline form
     },
   },
 })

package/dist/adapter/collections.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../../src/adapter/collections.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAU,gBAAgB,EAAS,MAAM,EAA8B,MAAM,SAAS,CAAA;AAClG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAEpD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AAEvE,YAAY,EAAE,qBAAqB,EAAE,CAAA;AAErC,MAAM,MAAM,4BAA4B,GAAG;IACzC;;;OAGG;IACH,iBAAiB,CAAC,EAAE,iBAAiB,CAAA;IAErC;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAE1B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;;OAGG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAA;IAEnC;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IAEnB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAE5B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,cAAc,CAAC,EAAE,OAAO,GAAG,qBAAqB,CAAA;IAEhD;;;;;;;;;;;;;;;;;;OAkBG;IACH,mBAAmB,CAAC,EAAE,CACpB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,gBAAgB,KACzB,gBAAgB,CAAA;CACtB,CAAA;AA2XD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,GAAE,4BAAiC,GACzC,MAAM,CAuGR"}
+{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../../src/adapter/collections.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAU,gBAAgB,EAAS,MAAM,EAA8B,MAAM,SAAS,CAAA;AAClG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAEpD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AAGvE,YAAY,EAAE,qBAAqB,EAAE,CAAA;AAErC,MAAM,MAAM,4BAA4B,GAAG;IACzC;;;OAGG;IACH,iBAAiB,CAAC,EAAE,iBAAiB,CAAA;IAErC;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAE1B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;;OAGG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAA;IAEnC;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IAEnB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAE5B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,cAAc,CAAC,EAAE,OAAO,GAAG,qBAAqB,CAAA;IAEhD;;;;;;;;;;;;;;;;;;OAkBG;IACH,mBAAmB,CAAC,EAAE,CACpB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,gBAAgB,KACzB,gBAAgB,CAAA;CACtB,CAAA;AA2XD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,GAAE,4BAAiC,GACzC,MAAM,CAuGR"}

package/dist/adapter/collections.js

@@ -2,69 +2,82 @@
  * Auto-generate Payload collections from Better Auth schema
  *
  * @packageDocumentation
- */
-import { getAuthTables } from 'better-auth/db';
+ */ import { getAuthTables } from 'better-auth/db';
+import { isAdmin } from '../utils/access.js';
 /**
  * Creates a beforeChange hook that makes the first user an admin.
- */
-function createFirstUserAdminHook(options, usersSlug) {
-    const { adminRole = 'admin', defaultRole = 'user', roleField = 'role', } = options;
-    return async ({ data, operation, req }) => {
+ */ function createFirstUserAdminHook(options, usersSlug) {
+    const { adminRole = 'admin', defaultRole = 'user', roleField = 'role' } = options;
+    return async ({ data, operation, req })=>{
         if (operation !== 'create') {
             return data;
         }
         try {
             const { totalDocs } = await req.payload.count({
                 collection: usersSlug,
-                overrideAccess: true,
+                overrideAccess: true
             });
             if (totalDocs === 0) {
                 // First user becomes admin
                 return {
                     ...data,
-                    [roleField]: adminRole,
+                    [roleField]: adminRole
                 };
             }
             // Subsequent users get default role if not already set
             return {
                 ...data,
-                [roleField]: data[roleField] ?? defaultRole,
+                [roleField]: data[roleField] ?? defaultRole
             };
-        }
-        catch (error) {
+        } catch (error) {
             // On error, don't block user creation - just use provided or default role
             console.warn('[betterAuthCollections] Failed to check user count:', error);
             return {
                 ...data,
-                [roleField]: data[roleField] ?? defaultRole,
+                [roleField]: data[roleField] ?? defaultRole
             };
         }
     };
 }
 /**
  * Inject the first-user-admin hook into a collection's hooks.
- */
-function injectFirstUserAdminHook(collection, options, usersSlug) {
+ */ function injectFirstUserAdminHook(collection, options, usersSlug) {
     const hook = createFirstUserAdminHook(options, usersSlug);
     const existingHooks = collection.hooks?.beforeChange ?? [];
     return {
         ...collection,
         hooks: {
             ...collection.hooks,
-            beforeChange: [hook, ...(Array.isArray(existingHooks) ? existingHooks : [existingHooks])],
-        },
+            beforeChange: [
+                hook,
+                ...Array.isArray(existingHooks) ? existingHooks : [
+                    existingHooks
+                ]
+            ]
+        }
     };
 }
 /**
  * Determine if a field should be saved to JWT.
  * Session-critical fields are included, large data fields are excluded.
- */
-function getSaveToJWT(modelKey, fieldName) {
+ */ function getSaveToJWT(modelKey, fieldName) {
     // Session fields - include core session data
     if (modelKey === 'session') {
-        const includeFields = ['token', 'expiresAt', 'user', 'userId', 'ipAddress', 'userAgent', 'activeOrganizationId', 'activeTeamId'];
-        const excludeFields = ['createdAt', 'updatedAt'];
-        if (includeFields.some(f => fieldName === f || fieldName.endsWith(f.charAt(0).toUpperCase() + f.slice(1)))) {
+        const includeFields = [
+            'token',
+            'expiresAt',
+            'user',
+            'userId',
+            'ipAddress',
+            'userAgent',
+            'activeOrganizationId',
+            'activeTeamId'
+        ];
+        const excludeFields = [
+            'createdAt',
+            'updatedAt'
+        ];
+        if (includeFields.some((f)=>fieldName === f || fieldName.endsWith(f.charAt(0).toUpperCase() + f.slice(1)))) {
             return true;
         }
         if (excludeFields.includes(fieldName)) {
@@ -73,8 +86,19 @@ function getSaveToJWT(modelKey, fieldName) {
     }
     // User fields - include essential auth data
     if (modelKey === 'user') {
-        const includeFields = ['role', 'email', 'emailVerified', 'name', 'twoFactorEnabled', 'banned'];
-        const excludeFields = ['image', 'password', 'banReason'];
+        const includeFields = [
+            'role',
+            'email',
+            'emailVerified',
+            'name',
+            'twoFactorEnabled',
+            'banned'
+        ];
+        const excludeFields = [
+            'image',
+            'password',
+            'banReason'
+        ];
         if (includeFields.includes(fieldName)) {
             return true;
         }
@@ -95,17 +119,15 @@ function getSaveToJWT(modelKey, fieldName) {
 }
 /**
  * Simple pluralization (add 's' suffix)
- */
-function pluralize(name) {
-    if (name.endsWith('s'))
-        return name;
+ */ function pluralize(name) {
+    if (name.endsWith('s')) return name;
     return `${name}s`;
 }
 function mapFieldType(type, fieldName, hasReferences) {
     if (hasReferences) {
         return 'relationship';
     }
-    switch (type) {
+    switch(type){
         case 'boolean':
             return 'checkbox';
         case 'number':
@@ -113,15 +135,15 @@ function mapFieldType(type, fieldName, hasReferences) {
         case 'date':
             return 'date';
         case 'string':
-            if (fieldName === 'email')
-                return 'email';
+            if (fieldName === 'email') return 'email';
             return 'text';
         case 'json':
         case 'object':
             return 'json';
         case 'string[]':
         case 'array':
-            return 'json'; // Payload doesn't have native string array, use JSON
+            return 'json' // Payload doesn't have native string array, use JSON
+            ;
         default:
             return 'text';
     }
@@ -135,8 +157,12 @@ function generateCollection(modelKey, table, usePlural, adminGroup, customAccess
     const baseName = table.modelName ?? modelKey;
     const slug = usePlural ? pluralize(baseName) : baseName;
     const fields = [];
-    for (const [fieldKey, fieldDef] of Object.entries(table.fields)) {
-        if (['id', 'createdAt', 'updatedAt'].includes(fieldKey)) {
+    for (const [fieldKey, fieldDef] of Object.entries(table.fields)){
+        if ([
+            'id',
+            'createdAt',
+            'updatedAt'
+        ].includes(fieldKey)) {
             continue;
         }
         const fieldName = fieldDef.fieldName ?? fieldKey;
@@ -147,8 +173,7 @@ function generateCollection(modelKey, table, usePlural, adminGroup, customAccess
             let relationTo;
             if (fieldDef.references?.model) {
                 relationTo = usePlural ? pluralize(fieldDef.references.model) : fieldDef.references.model;
-            }
-            else {
+            } else {
                 relationTo = extractRelationTarget(fieldKey, usePlural);
             }
             const relFieldName = fieldName.replace(/(_id|Id)$/, '');
@@ -159,7 +184,9 @@ function generateCollection(modelKey, table, usePlural, adminGroup, customAccess
                 relationTo,
                 required: fieldDef.required ?? false,
                 index: true,
-                ...(saveToJWT !== undefined && { saveToJWT }),
+                ...saveToJWT !== undefined && {
+                    saveToJWT
+                }
             });
             continue;
         }
@@ -167,10 +194,11 @@ function generateCollection(modelKey, table, usePlural, adminGroup, customAccess
         const field = {
             name: fieldName,
             type: fieldType,
-            ...(saveToJWT !== undefined && { saveToJWT }),
+            ...saveToJWT !== undefined && {
+                saveToJWT
+            }
         };
-        if (fieldDef.required)
-            field.required = true;
+        if (fieldDef.required) field.required = true;
         if (fieldDef.unique) {
             field.unique = true;
             field.index = true;
@@ -180,8 +208,7 @@ function generateCollection(modelKey, table, usePlural, adminGroup, customAccess
             if (typeof defaultValue === 'function') {
                 try {
                     defaultValue = defaultValue();
-                }
-                catch {
+                } catch  {
                     defaultValue = undefined;
                 }
             }
@@ -191,33 +218,37 @@ function generateCollection(modelKey, table, usePlural, adminGroup, customAccess
         }
         fields.push(field);
     }
-    const titleField = ['name', 'email', 'title', 'identifier'].find((f) => fields.some((field) => 'name' in field && field.name === f));
+    const titleField = [
+        'name',
+        'email',
+        'title',
+        'identifier'
+    ].find((f)=>fields.some((field)=>'name' in field && field.name === f));
     // Default access: admin-only read/delete, disabled manual create/update via admin UI
     // The adapter uses overrideAccess: true for programmatic operations from Better Auth
     const defaultAccess = {
-        read: ({ req }) => req.user?.role === 'admin',
-        create: () => false, // Manual creation disabled - Better Auth manages these
-        update: () => false, // Manual update disabled - Better Auth manages these
-        delete: ({ req }) => req.user?.role === 'admin',
+        read: isAdmin(),
+        create: ()=>false,
+        update: ()=>false,
+        delete: isAdmin()
     };
     return {
         slug,
         admin: {
             useAsTitle: titleField ?? 'id',
             group: adminGroup,
-            description: `Auto-generated from Better Auth schema (${modelKey})`,
+            description: `Auto-generated from Better Auth schema (${modelKey})`
         },
         access: customAccess ?? defaultAccess,
         fields,
-        timestamps: true,
+        timestamps: true
     };
 }
 /**
  * Get existing field names from a collection, handling nested field structures.
- */
-function getExistingFieldNames(fields) {
+ */ function getExistingFieldNames(fields) {
     const names = new Set();
-    for (const field of fields) {
+    for (const field of fields){
         if ('name' in field && field.name) {
             names.add(field.name);
         }
@@ -227,21 +258,22 @@ function getExistingFieldNames(fields) {
 /**
  * Augment an existing collection with missing fields from Better Auth schema.
  * This ensures user-defined collections (like 'users') get plugin fields automatically.
- */
-function augmentCollectionWithMissingFields(collection, table, usePlural, modelKey, configureSaveToJWT = true) {
+ */ function augmentCollectionWithMissingFields(collection, table, usePlural, modelKey, configureSaveToJWT = true) {
     const existingFieldNames = getExistingFieldNames(collection.fields);
     const missingFields = [];
-    for (const [fieldKey, fieldDef] of Object.entries(table.fields)) {
+    for (const [fieldKey, fieldDef] of Object.entries(table.fields)){
         // Skip standard fields that Payload handles
-        if (['id', 'createdAt', 'updatedAt'].includes(fieldKey)) {
+        if ([
+            'id',
+            'createdAt',
+            'updatedAt'
+        ].includes(fieldKey)) {
             continue;
         }
         const fieldName = fieldDef.fieldName ?? fieldKey;
         const hasReferences = fieldDef.references !== undefined;
         // For reference fields, check the name without Id suffix
-        const payloadFieldName = hasReferences
-            ? fieldName.replace(/(_id|Id)$/, '')
-            : fieldName;
+        const payloadFieldName = hasReferences ? fieldName.replace(/(_id|Id)$/, '') : fieldName;
         // Skip if field already exists
         if (existingFieldNames.has(payloadFieldName)) {
             continue;
@@ -252,8 +284,7 @@ function augmentCollectionWithMissingFields(collection, table, usePlural, modelK
             let relationTo;
             if (fieldDef.references?.model) {
                 relationTo = usePlural ? pluralize(fieldDef.references.model) : fieldDef.references.model;
-            }
-            else {
+            } else {
                 relationTo = extractRelationTarget(fieldKey, usePlural);
             }
             const saveToJWT = configureSaveToJWT ? getSaveToJWT(modelKey, payloadFieldName) : undefined;
@@ -264,23 +295,25 @@ function augmentCollectionWithMissingFields(collection, table, usePlural, modelK
                 required: fieldDef.required ?? false,
                 index: true,
                 admin: {
-                    description: `Auto-added by Better Auth (${fieldKey})`,
+                    description: `Auto-added by Better Auth (${fieldKey})`
                 },
-                ...(saveToJWT !== undefined && { saveToJWT }),
+                ...saveToJWT !== undefined && {
+                    saveToJWT
+                }
             });
-        }
-        else {
+        } else {
             const saveToJWT = configureSaveToJWT ? getSaveToJWT(modelKey, payloadFieldName) : undefined;
             const field = {
                 name: payloadFieldName,
                 type: fieldType,
                 admin: {
-                    description: `Auto-added by Better Auth (${fieldKey})`,
+                    description: `Auto-added by Better Auth (${fieldKey})`
                 },
-                ...(saveToJWT !== undefined && { saveToJWT }),
+                ...saveToJWT !== undefined && {
+                    saveToJWT
+                }
             };
-            if (fieldDef.required)
-                field.required = true;
+            if (fieldDef.required) field.required = true;
             if (fieldDef.unique) {
                 field.unique = true;
                 field.index = true;
@@ -290,8 +323,7 @@ function augmentCollectionWithMissingFields(collection, table, usePlural, modelK
                 if (typeof defaultValue === 'function') {
                     try {
                         defaultValue = defaultValue();
-                    }
-                    catch {
+                    } catch  {
                         defaultValue = undefined;
                     }
                 }
@@ -309,7 +341,10 @@ function augmentCollectionWithMissingFields(collection, table, usePlural, modelK
     // Return augmented collection
     return {
         ...collection,
-        fields: [...collection.fields, ...missingFields],
+        fields: [
+            ...collection.fields,
+            ...missingFields
+        ]
     };
 }
 /**
@@ -344,26 +379,25 @@ function augmentCollectionWithMissingFields(collection, table, usePlural, modelK
  *   },
  * })
  * ```
- */
-export function betterAuthCollections(options = {}) {
-    const { betterAuthOptions = {}, skipCollections = ['user'], adminGroup = 'Auth', access, usePlural = true, configureSaveToJWT = true, firstUserAdmin, customizeCollection, } = options;
+ */ export function betterAuthCollections(options = {}) {
+    const { betterAuthOptions = {}, skipCollections = [
+        'user'
+    ], adminGroup = 'Auth', access, usePlural = true, configureSaveToJWT = true, firstUserAdmin, customizeCollection } = options;
     // Parse firstUserAdmin option (defaults to true)
-    const firstUserAdminOptions = firstUserAdmin === false
-        ? null
-        : typeof firstUserAdmin === 'object'
-            ? firstUserAdmin
-            : {}; // true or undefined = enabled with defaults
-    return (incomingConfig) => {
-        const existingCollections = new Map((incomingConfig.collections ?? []).map((c) => [c.slug, c]));
+    const firstUserAdminOptions = firstUserAdmin === false ? null : typeof firstUserAdmin === 'object' ? firstUserAdmin : {} // true or undefined = enabled with defaults
+    ;
+    return (incomingConfig)=>{
+        const existingCollections = new Map((incomingConfig.collections ?? []).map((c)=>[
+                c.slug,
+                c
+            ]));
         const tables = getAuthTables(betterAuthOptions);
         const generatedCollections = [];
         const augmentedCollections = [];
         // Calculate users collection slug for firstUserAdmin hook
         const userTable = tables['user'];
-        const usersSlug = usePlural
-            ? pluralize(userTable?.modelName ?? 'user')
-            : (userTable?.modelName ?? 'user');
-        for (const [modelKey, table] of Object.entries(tables)) {
+        const usersSlug = usePlural ? pluralize(userTable?.modelName ?? 'user') : userTable?.modelName ?? 'user';
+        for (const [modelKey, table] of Object.entries(tables)){
             // Calculate slug
             const baseName = table.modelName ?? modelKey;
             const slug = usePlural ? pluralize(baseName) : baseName;
@@ -398,14 +432,18 @@ export function betterAuthCollections(options = {}) {
             generatedCollections.push(collection);
         }
         // Merge: replace augmented collections, add new ones
-        const finalCollections = (incomingConfig.collections ?? []).map((c) => {
-            const augmented = augmentedCollections.find((a) => a.slug === c.slug);
+        const finalCollections = (incomingConfig.collections ?? []).map((c)=>{
+            const augmented = augmentedCollections.find((a)=>a.slug === c.slug);
             return augmented ?? c;
         });
         return {
             ...incomingConfig,
-            collections: [...finalCollections, ...generatedCollections],
+            collections: [
+                ...finalCollections,
+                ...generatedCollections
+            ]
         };
     };
 }
+
 //# sourceMappingURL=collections.js.map