@luochuanyuewu/payload-auth 1.8.0

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

@@ -0,0 +1,333 @@
+import { checkPluginExists } from "../../../helpers/check-plugin-exists";
+import { baModelFieldKeys, baModelKey, defaults, supportedBAPluginIds } from "../../../constants";
+import { getAllRoleOptions } from "../../../helpers/get-all-roles";
+import { assertAllSchemaFields, getSchemaCollectionSlug, getSchemaFieldName } from "../utils/collection-schema";
+import { hasAdminRoles, isAdminOrCurrentUserUpdateWithAllowedFields, isAdminOrCurrentUserWithRoles, isAdminWithRoles } from "../utils/payload-access";
+import { getCollectionFields } from "../utils/transform-schema-fields-to-payload";
+import { betterAuthStrategy } from "./better-auth-strategy";
+import { getGenerateInviteUrlEndpoint, getRefreshTokenEndpoint, getSendInviteUrlEndpoint, getSetAdminRoleEndpoint } from "./endpoints";
+import { getAfterLoginHook, getAfterLogoutHook, getBeforeDeleteHook, getBeforeLoginHook, getOnVerifiedChangeHook, getSyncAccountHook } from "./hooks";
+export function buildUsersCollection({ incomingCollections, pluginOptions, resolvedSchemas }) {
+    const userSlug = getSchemaCollectionSlug(resolvedSchemas, baModelKey.user);
+    const passkeySlug = getSchemaCollectionSlug(resolvedSchemas, baModelKey.passkey);
+    const sessionSlug = getSchemaCollectionSlug(resolvedSchemas, baModelKey.session);
+    const accountSlug = getSchemaCollectionSlug(resolvedSchemas, baModelKey.account);
+    const passkeyUserIdFieldName = getSchemaFieldName(resolvedSchemas, baModelKey.passkey, baModelFieldKeys.passkey.userId);
+    const userSchema = resolvedSchemas[baModelKey.user];
+    const adminRoles = pluginOptions.users?.adminRoles ?? [
+        defaults.adminRole
+    ];
+    const allRoleOptions = getAllRoleOptions(pluginOptions);
+    const hasUsernamePlugin = checkPluginExists(pluginOptions.betterAuthOptions ?? {}, supportedBAPluginIds.username);
+    const existingUserCollection = incomingCollections.find((collection)=>collection.slug === userSlug);
+    // TODO: REVIEW THIS
+    const allowedFields = pluginOptions.users?.allowedFields ?? [
+        "name"
+    ];
+    const userFieldRules = [
+        {
+            condition: (field)=>field.fieldName === "createdAt" || field.fieldName === "updatedAt",
+            transform: (field)=>({
+                    ...field,
+                    saveToJWT: false,
+                    admin: {
+                        disableBulkEdit: true,
+                        hidden: true
+                    },
+                    index: true,
+                    label: ({ t })=>field.fieldName === "createdAt" ? t("general:createdAt") : t("general:updatedAt")
+                })
+        }
+    ];
+    const fieldOverrides = {
+        role: (field)=>({
+                type: "select",
+                hasMany: true,
+                options: allRoleOptions,
+                defaultValue: field.defaultValue ?? defaults.userRole,
+                saveToJWT: true,
+                admin: {
+                    description: "The role/ roles of the user"
+                }
+            }),
+        email: ()=>({
+                index: true,
+                admin: {
+                    description: "The email of the user"
+                }
+            }),
+        emailVerified: (field)=>({
+                defaultValue: field.defaultValue ?? false,
+                saveToJWT: true,
+                admin: {
+                    description: "Whether the email of the user has been verified"
+                }
+            }),
+        name: ()=>({
+                saveToJWT: true,
+                admin: {
+                    description: "Users chosen display name"
+                }
+            }),
+        image: ()=>({
+                saveToJWT: false,
+                admin: {
+                    description: "The image of the user"
+                }
+            }),
+        twoFactorEnabled: ()=>({
+                defaultValue: false,
+                admin: {
+                    description: "Whether the user has two factor authentication enabled",
+                    components: {
+                        Field: {
+                            path: "payload-auth/better-auth/plugin/client#TwoFactorAuth"
+                        }
+                    }
+                }
+            }),
+        username: ()=>({
+                admin: {
+                    description: "The username of the user"
+                }
+            }),
+        displayUsername: ()=>({
+                admin: {
+                    description: "The display username of the user"
+                }
+            }),
+        isAnonymous: ()=>({
+                defaultValue: false,
+                admin: {
+                    description: "Whether the user is anonymous."
+                }
+            }),
+        phoneNumber: ()=>({
+                admin: {
+                    description: "The phone number of the user"
+                }
+            }),
+        phoneNumberVerified: ()=>({
+                defaultValue: false,
+                admin: {
+                    description: "Whether the phone number of the user has been verified"
+                }
+            }),
+        banned: ()=>({
+                defaultValue: false,
+                admin: {
+                    description: "Whether the user is banned from the platform"
+                }
+            }),
+        banReason: ()=>({
+                admin: {
+                    description: "The reason for the ban"
+                }
+            }),
+        banExpires: ()=>({
+                admin: {
+                    description: "The date and time when the ban will expire"
+                }
+            }),
+        normalizedEmail: ()=>({
+                admin: {
+                    readOnly: true,
+                    description: "The normalized email of the user"
+                }
+            }),
+        stripeCustomerId: ()=>({
+                admin: {
+                    readOnly: true,
+                    description: "The Stripe customer ID of the user"
+                }
+            })
+    };
+    const collectionFields = getCollectionFields({
+        schema: userSchema,
+        fieldRules: userFieldRules,
+        additionalProperties: fieldOverrides
+    });
+    const joinFields = [
+        // Better Auth’s internal adapter renames `account` => `accounts` via
+        // `const { account: accounts, ...user } = result`
+        // @see https://github.com/better-auth/better-auth/blob/28654734e13dc0bb22d5623722e97b9a8dbc1b37/packages/better-auth/src/db/internal-adapter.ts#L760-L761
+        // The join field name must therefore stay exactly `account` to be picked up.
+        {
+            label: "Accounts",
+            name: baModelKey.account,
+            type: "join",
+            hasMany: true,
+            collection: accountSlug,
+            on: getSchemaFieldName(resolvedSchemas, baModelKey.account, baModelFieldKeys.account.userId),
+            maxDepth: 1,
+            saveToJWT: false
+        },
+        // Sessions use the same pattern; keep the singular model key for the join name.
+        {
+            label: "Sessions",
+            name: baModelKey.session,
+            type: "join",
+            hasMany: true,
+            collection: sessionSlug,
+            on: getSchemaFieldName(resolvedSchemas, baModelKey.session, baModelFieldKeys.session.userId),
+            maxDepth: 1,
+            saveToJWT: false
+        }
+    ];
+    let usersCollection = {
+        ...existingUserCollection,
+        slug: userSlug,
+        admin: {
+            defaultColumns: [
+                "email"
+            ],
+            useAsTitle: "email",
+            group: pluginOptions?.collectionAdminGroup ?? "Auth",
+            ...existingUserCollection?.admin,
+            hidden: pluginOptions.users?.hidden ?? false,
+            components: {
+                Description: {
+                    path: "payload-auth/better-auth/plugin/client#AdminInviteButton",
+                    clientProps: {
+                        roles: allRoleOptions
+                    }
+                },
+                views: {
+                    edit: {
+                        adminButtons: {
+                            tab: {
+                                Component: {
+                                    path: "payload-auth/better-auth/plugin/client#AdminButtons",
+                                    clientProps: {
+                                        userSlug,
+                                        baseURL: pluginOptions.betterAuthOptions?.baseURL,
+                                        basePath: pluginOptions.betterAuthOptions?.basePath
+                                    }
+                                },
+                                condition: ()=>{
+                                    // Only show the impersonate button if the admin plugin is enabled
+                                    return checkPluginExists(pluginOptions.betterAuthOptions ?? {}, supportedBAPluginIds.admin);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        access: {
+            admin: hasAdminRoles(adminRoles),
+            read: isAdminOrCurrentUserWithRoles({
+                adminRoles,
+                idField: "id"
+            }),
+            create: isAdminWithRoles({
+                adminRoles
+            }),
+            delete: isAdminOrCurrentUserWithRoles({
+                adminRoles,
+                idField: "id"
+            }),
+            update: isAdminOrCurrentUserUpdateWithAllowedFields({
+                allowedFields,
+                adminRoles,
+                userSlug
+            }),
+            ...existingUserCollection?.access ?? {}
+        },
+        custom: {
+            ...existingUserCollection?.custom ?? {},
+            betterAuthModelKey: baModelKey.user
+        },
+        endpoints: [
+            ...existingUserCollection?.endpoints ? existingUserCollection.endpoints : [],
+            getRefreshTokenEndpoint(userSlug),
+            getSetAdminRoleEndpoint(pluginOptions, userSlug),
+            getGenerateInviteUrlEndpoint({
+                roles: allRoleOptions,
+                pluginOptions
+            }),
+            getSendInviteUrlEndpoint(pluginOptions)
+        ],
+        hooks: {
+            beforeChange: [
+                ...existingUserCollection?.hooks?.beforeChange ?? [],
+                ...pluginOptions.disableDefaultPayloadAuth ? [] : [
+                    getOnVerifiedChangeHook()
+                ]
+            ],
+            afterChange: [
+                ...existingUserCollection?.hooks?.afterChange ?? [],
+                ...pluginOptions.disableDefaultPayloadAuth ? [] : [
+                    getSyncAccountHook()
+                ]
+            ],
+            beforeLogin: [
+                ...existingUserCollection?.hooks?.beforeLogin ?? [],
+                ...pluginOptions.disableDefaultPayloadAuth ? [] : [
+                    getBeforeLoginHook(pluginOptions.betterAuthOptions ?? {})
+                ]
+            ],
+            afterLogin: [
+                ...existingUserCollection?.hooks?.afterLogin ?? [],
+                ...pluginOptions.disableDefaultPayloadAuth ? [] : [
+                    getAfterLoginHook()
+                ]
+            ],
+            afterLogout: [
+                ...existingUserCollection?.hooks?.afterLogout ?? [],
+                getAfterLogoutHook()
+            ],
+            beforeDelete: [
+                ...existingUserCollection?.hooks?.beforeDelete ?? [],
+                getBeforeDeleteHook()
+            ]
+        },
+        auth: {
+            ...existingUserCollection && typeof existingUserCollection.auth === "object" ? existingUserCollection.auth : {},
+            disableLocalStrategy: pluginOptions.disableDefaultPayloadAuth ? true : undefined,
+            ...hasUsernamePlugin && {
+                loginWithUsername: {
+                    allowEmailLogin: true,
+                    requireEmail: true,
+                    requireUsername: false
+                }
+            },
+            strategies: [
+                betterAuthStrategy(userSlug)
+            ]
+        },
+        fields: [
+            ...existingUserCollection?.fields ?? [],
+            ...collectionFields ?? [],
+            ...joinFields,
+            ...checkPluginExists(pluginOptions.betterAuthOptions ?? {}, supportedBAPluginIds.passkey) ? [
+                {
+                    name: "managePasskeys",
+                    type: "ui",
+                    admin: {
+                        disableBulkEdit: true,
+                        components: {
+                            Field: {
+                                path: "payload-auth/better-auth/plugin/rsc#Passkeys",
+                                serverProps: {
+                                    passkeyUserIdFieldName,
+                                    passkeySlug,
+                                    pluginOptions
+                                }
+                            }
+                        }
+                    }
+                }
+            ] : []
+        ]
+    };
+    if (pluginOptions.users?.collectionOverrides) {
+        usersCollection = pluginOptions.users.collectionOverrides({
+            collection: usersCollection
+        });
+    }
+    assertAllSchemaFields(usersCollection, userSchema);
+    return usersCollection;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/better-auth/plugin/lib/build-collections/users/index.ts"],"sourcesContent":["import type { User } from \"@/better-auth/generated-types\";\nimport { checkPluginExists } from \"@/better-auth/plugin/helpers/check-plugin-exists\";\nimport type { CollectionConfig, JoinField, UIField } from \"payload\";\nimport {\n  baModelFieldKeys,\n  baModelKey,\n  defaults,\n  supportedBAPluginIds\n} from \"../../../constants\";\nimport { getAllRoleOptions } from \"../../../helpers/get-all-roles\";\nimport type {\n  BuildCollectionProps,\n  FieldOverrides,\n  FieldRule\n} from \"../../../types\";\nimport {\n  assertAllSchemaFields,\n  getSchemaCollectionSlug,\n  getSchemaFieldName\n} from \"../utils/collection-schema\";\nimport {\n  hasAdminRoles,\n  isAdminOrCurrentUserUpdateWithAllowedFields,\n  isAdminOrCurrentUserWithRoles,\n  isAdminWithRoles\n} from \"../utils/payload-access\";\nimport { getCollectionFields } from \"../utils/transform-schema-fields-to-payload\";\nimport { betterAuthStrategy } from \"./better-auth-strategy\";\nimport {\n  getGenerateInviteUrlEndpoint,\n  getRefreshTokenEndpoint,\n  getSendInviteUrlEndpoint,\n  getSetAdminRoleEndpoint\n} from \"./endpoints\";\nimport {\n  getAfterLoginHook,\n  getAfterLogoutHook,\n  getBeforeDeleteHook,\n  getBeforeLoginHook,\n  getOnVerifiedChangeHook,\n  getSyncAccountHook\n} from \"./hooks\";\n\nexport function buildUsersCollection({\n  incomingCollections,\n  pluginOptions,\n  resolvedSchemas\n}: BuildCollectionProps): CollectionConfig {\n  const userSlug = getSchemaCollectionSlug(resolvedSchemas, baModelKey.user);\n  const passkeySlug = getSchemaCollectionSlug(\n    resolvedSchemas,\n    baModelKey.passkey\n  );\n  const sessionSlug = getSchemaCollectionSlug(\n    resolvedSchemas,\n    baModelKey.session\n  );\n  const accountSlug = getSchemaCollectionSlug(\n    resolvedSchemas,\n    baModelKey.account\n  );\n  const passkeyUserIdFieldName = getSchemaFieldName(\n    resolvedSchemas,\n    baModelKey.passkey,\n    baModelFieldKeys.passkey.userId\n  );\n  const userSchema = resolvedSchemas[baModelKey.user];\n  const adminRoles = pluginOptions.users?.adminRoles ?? [defaults.adminRole];\n  const allRoleOptions = getAllRoleOptions(pluginOptions);\n  const hasUsernamePlugin = checkPluginExists(\n    pluginOptions.betterAuthOptions ?? {},\n    supportedBAPluginIds.username\n  );\n  const existingUserCollection = incomingCollections.find(\n    (collection) => collection.slug === userSlug\n  ) as CollectionConfig | undefined;\n\n  // TODO: REVIEW THIS\n  const allowedFields = pluginOptions.users?.allowedFields ?? [\"name\"];\n\n  const userFieldRules: FieldRule[] = [\n    {\n      condition: (field) =>\n        field.fieldName === \"createdAt\" || field.fieldName === \"updatedAt\",\n      transform: (field) => ({\n        ...field,\n        saveToJWT: false,\n        admin: {\n          disableBulkEdit: true,\n          hidden: true\n        },\n        index: true,\n        label: ({ t }: any) =>\n          field.fieldName === \"createdAt\"\n            ? t(\"general:createdAt\")\n            : t(\"general:updatedAt\")\n      })\n    }\n  ];\n\n  const fieldOverrides: FieldOverrides<keyof User> = {\n    role: (field) => ({\n      type: \"select\",\n      hasMany: true,\n      options: allRoleOptions,\n      defaultValue: field.defaultValue ?? defaults.userRole,\n      saveToJWT: true,\n      admin: { description: \"The role/ roles of the user\" }\n    }),\n    email: () => ({\n      index: true,\n      admin: { description: \"The email of the user\" }\n    }),\n    emailVerified: (field) => ({\n      defaultValue: field.defaultValue ?? false,\n      saveToJWT: true,\n      admin: { description: \"Whether the email of the user has been verified\" }\n    }),\n    name: () => ({\n      saveToJWT: true,\n      admin: { description: \"Users chosen display name\" }\n    }),\n    image: () => ({\n      saveToJWT: false,\n      admin: { description: \"The image of the user\" }\n    }),\n    twoFactorEnabled: () => ({\n      defaultValue: false,\n      admin: {\n        description: \"Whether the user has two factor authentication enabled\",\n        components: {\n          Field: {\n            path: \"payload-auth/better-auth/plugin/client#TwoFactorAuth\"\n          }\n        }\n      }\n    }),\n    username: () => ({\n      admin: { description: \"The username of the user\" }\n    }),\n    displayUsername: () => ({\n      admin: { description: \"The display username of the user\" }\n    }),\n    isAnonymous: () => ({\n      defaultValue: false,\n      admin: { description: \"Whether the user is anonymous.\" }\n    }),\n    phoneNumber: () => ({\n      admin: { description: \"The phone number of the user\" }\n    }),\n    phoneNumberVerified: () => ({\n      defaultValue: false,\n      admin: {\n        description: \"Whether the phone number of the user has been verified\"\n      }\n    }),\n    banned: () => ({\n      defaultValue: false,\n      admin: { description: \"Whether the user is banned from the platform\" }\n    }),\n    banReason: () => ({\n      admin: { description: \"The reason for the ban\" }\n    }),\n    banExpires: () => ({\n      admin: { description: \"The date and time when the ban will expire\" }\n    }),\n    normalizedEmail: () => ({\n      admin: {\n        readOnly: true,\n        description: \"The normalized email of the user\"\n      }\n    }),\n    stripeCustomerId: () => ({\n      admin: {\n        readOnly: true,\n        description: \"The Stripe customer ID of the user\"\n      }\n    })\n  };\n\n  const collectionFields = getCollectionFields({\n    schema: userSchema,\n    fieldRules: userFieldRules,\n    additionalProperties: fieldOverrides\n  });\n\n  const joinFields: JoinField[] = [\n    // Better Auth’s internal adapter renames `account` => `accounts` via\n    // `const { account: accounts, ...user } = result`\n    // @see https://github.com/better-auth/better-auth/blob/28654734e13dc0bb22d5623722e97b9a8dbc1b37/packages/better-auth/src/db/internal-adapter.ts#L760-L761\n    // The join field name must therefore stay exactly `account` to be picked up.\n    {\n      label: \"Accounts\",\n      name: baModelKey.account,\n      type: \"join\",\n      hasMany: true,\n      collection: accountSlug,\n      on: getSchemaFieldName(\n        resolvedSchemas,\n        baModelKey.account,\n        baModelFieldKeys.account.userId\n      ),\n      maxDepth: 1,\n      saveToJWT: false\n    },\n    // Sessions use the same pattern; keep the singular model key for the join name.\n    {\n      label: \"Sessions\",\n      name: baModelKey.session,\n      type: \"join\",\n      hasMany: true,\n      collection: sessionSlug,\n      on: getSchemaFieldName(\n        resolvedSchemas,\n        baModelKey.session,\n        baModelFieldKeys.session.userId\n      ),\n      maxDepth: 1,\n      saveToJWT: false\n    }\n  ];\n\n  let usersCollection: CollectionConfig = {\n    ...existingUserCollection,\n    slug: userSlug,\n    admin: {\n      defaultColumns: [\"email\"],\n      useAsTitle: \"email\",\n      group: pluginOptions?.collectionAdminGroup ?? \"Auth\",\n      ...existingUserCollection?.admin,\n      hidden: pluginOptions.users?.hidden ?? false,\n      components: {\n        Description: {\n          path: \"payload-auth/better-auth/plugin/client#AdminInviteButton\",\n          clientProps: {\n            roles: allRoleOptions\n          }\n        },\n        views: {\n          edit: {\n            adminButtons: {\n              tab: {\n                Component: {\n                  path: \"payload-auth/better-auth/plugin/client#AdminButtons\",\n                  clientProps: {\n                    userSlug,\n                    baseURL: pluginOptions.betterAuthOptions?.baseURL,\n                    basePath: pluginOptions.betterAuthOptions?.basePath\n                  }\n                },\n                condition: () => {\n                  // Only show the impersonate button if the admin plugin is enabled\n                  return checkPluginExists(\n                    pluginOptions.betterAuthOptions ?? {},\n                    supportedBAPluginIds.admin\n                  );\n                }\n              }\n            }\n          }\n        }\n      }\n    },\n    access: {\n      admin: hasAdminRoles(adminRoles),\n      read: isAdminOrCurrentUserWithRoles({ adminRoles, idField: \"id\" }),\n      create: isAdminWithRoles({ adminRoles }),\n      delete: isAdminOrCurrentUserWithRoles({ adminRoles, idField: \"id\" }),\n      update: isAdminOrCurrentUserUpdateWithAllowedFields({\n        allowedFields,\n        adminRoles,\n        userSlug\n      }),\n      ...(existingUserCollection?.access ?? {})\n    },\n    custom: {\n      ...(existingUserCollection?.custom ?? {}),\n      betterAuthModelKey: baModelKey.user\n    },\n    endpoints: [\n      ...(existingUserCollection?.endpoints\n        ? existingUserCollection.endpoints\n        : []),\n      getRefreshTokenEndpoint(userSlug),\n      getSetAdminRoleEndpoint(pluginOptions, userSlug),\n      getGenerateInviteUrlEndpoint({\n        roles: allRoleOptions,\n        pluginOptions\n      }),\n      getSendInviteUrlEndpoint(pluginOptions)\n    ],\n    hooks: {\n      beforeChange: [\n        ...(existingUserCollection?.hooks?.beforeChange ?? []),\n        ...(pluginOptions.disableDefaultPayloadAuth\n          ? []\n          : [getOnVerifiedChangeHook()])\n      ],\n      afterChange: [\n        ...(existingUserCollection?.hooks?.afterChange ?? []),\n        ...(pluginOptions.disableDefaultPayloadAuth\n          ? []\n          : [getSyncAccountHook()])\n      ],\n      beforeLogin: [\n        ...(existingUserCollection?.hooks?.beforeLogin ?? []),\n        ...(pluginOptions.disableDefaultPayloadAuth\n          ? []\n          : [getBeforeLoginHook(pluginOptions.betterAuthOptions ?? {})])\n      ],\n      afterLogin: [\n        ...(existingUserCollection?.hooks?.afterLogin ?? []),\n        ...(pluginOptions.disableDefaultPayloadAuth\n          ? []\n          : [getAfterLoginHook()])\n      ],\n      afterLogout: [\n        ...(existingUserCollection?.hooks?.afterLogout ?? []),\n        getAfterLogoutHook()\n      ],\n      beforeDelete: [\n        ...(existingUserCollection?.hooks?.beforeDelete ?? []),\n        getBeforeDeleteHook()\n      ]\n    },\n    auth: {\n      ...(existingUserCollection &&\n      typeof existingUserCollection.auth === \"object\"\n        ? existingUserCollection.auth\n        : {}),\n      disableLocalStrategy: pluginOptions.disableDefaultPayloadAuth\n        ? true\n        : undefined,\n      ...(hasUsernamePlugin && {\n        loginWithUsername: {\n          allowEmailLogin: true,\n          requireEmail: true,\n          requireUsername: false\n        }\n      }),\n      strategies: [betterAuthStrategy(userSlug)]\n    },\n    fields: [\n      ...(existingUserCollection?.fields ?? []),\n      ...(collectionFields ?? []),\n      ...joinFields,\n      ...(checkPluginExists(\n        pluginOptions.betterAuthOptions ?? {},\n        supportedBAPluginIds.passkey\n      )\n        ? [\n            {\n              name: \"managePasskeys\",\n              type: \"ui\" as const,\n              admin: {\n                disableBulkEdit: true,\n                components: {\n                  Field: {\n                    path: \"payload-auth/better-auth/plugin/rsc#Passkeys\",\n                    serverProps: {\n                      passkeyUserIdFieldName,\n                      passkeySlug,\n                      pluginOptions\n                    }\n                  }\n                }\n              }\n            } as UIField\n          ]\n        : [])\n    ]\n  };\n\n  if (pluginOptions.users?.collectionOverrides) {\n    usersCollection = pluginOptions.users.collectionOverrides({\n      collection: usersCollection\n    });\n  }\n\n  assertAllSchemaFields(usersCollection, userSchema);\n\n  return usersCollection;\n}\n"],"names":["checkPluginExists","baModelFieldKeys","baModelKey","defaults","supportedBAPluginIds","getAllRoleOptions","assertAllSchemaFields","getSchemaCollectionSlug","getSchemaFieldName","hasAdminRoles","isAdminOrCurrentUserUpdateWithAllowedFields","isAdminOrCurrentUserWithRoles","isAdminWithRoles","getCollectionFields","betterAuthStrategy","getGenerateInviteUrlEndpoint","getRefreshTokenEndpoint","getSendInviteUrlEndpoint","getSetAdminRoleEndpoint","getAfterLoginHook","getAfterLogoutHook","getBeforeDeleteHook","getBeforeLoginHook","getOnVerifiedChangeHook","getSyncAccountHook","buildUsersCollection","incomingCollections","pluginOptions","resolvedSchemas","userSlug","user","passkeySlug","passkey","sessionSlug","session","accountSlug","account","passkeyUserIdFieldName","userId","userSchema","adminRoles","users","adminRole","allRoleOptions","hasUsernamePlugin","betterAuthOptions","username","existingUserCollection","find","collection","slug","allowedFields","userFieldRules","condition","field","fieldName","transform","saveToJWT","admin","disableBulkEdit","hidden","index","label","t","fieldOverrides","role","type","hasMany","options","defaultValue","userRole","description","email","emailVerified","name","image","twoFactorEnabled","components","Field","path","displayUsername","isAnonymous","phoneNumber","phoneNumberVerified","banned","banReason","banExpires","normalizedEmail","readOnly","stripeCustomerId","collectionFields","schema","fieldRules","additionalProperties","joinFields","on","maxDepth","usersCollection","defaultColumns","useAsTitle","group","collectionAdminGroup","Description","clientProps","roles","views","edit","adminButtons","tab","Component","baseURL","basePath","access","read","idField","create","delete","update","custom","betterAuthModelKey","endpoints","hooks","beforeChange","disableDefaultPayloadAuth","afterChange","beforeLogin","afterLogin","afterLogout","beforeDelete","auth","disableLocalStrategy","undefined","loginWithUsername","allowEmailLogin","requireEmail","requireUsername","strategies","fields","serverProps","collectionOverrides"],"mappings":"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"}

package/dist/better-auth/plugin/lib/build-collections/utils/collection-schema.d.ts

@@ -0,0 +1,16 @@
+import { type CollectionConfig } from "payload";
+import type { BetterAuthFullSchema, ModelKey } from "@/better-auth/generated-types";
+import type { BetterAuthSchemas, BuiltBetterAuthSchema } from "@/better-auth/types";
+export declare function getSchemaCollectionSlug(resolvedSchemas: BetterAuthSchemas, model: ModelKey): string;
+export declare function getSchemaFieldName<M extends ModelKey>(resolvedSchemas: BetterAuthSchemas, model: M, fieldKey: Extract<keyof BetterAuthFullSchema[M], string>): string;
+/**
+ * Asserts that all field keys that exist in the schema exist in the collection
+ *
+ * It checks based on the custom.betterAuthFieldKey property.
+ *
+ * @param collection - The collection object
+ * @param schema - The schema object containing field definitions
+ * @throws {Error} If any required field is missing from the schema
+ */
+export declare function assertAllSchemaFields(collection: CollectionConfig, schema: BuiltBetterAuthSchema): void;
+//# sourceMappingURL=collection-schema.d.ts.map

package/dist/better-auth/plugin/lib/build-collections/utils/collection-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection-schema.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/lib/build-collections/utils/collection-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,SAAS,CAAC;AAClE,OAAO,KAAK,EACV,oBAAoB,EACpB,QAAQ,EACT,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EACV,iBAAiB,EACjB,qBAAqB,EACtB,MAAM,qBAAqB,CAAC;AAE7B,wBAAgB,uBAAuB,CACrC,eAAe,EAAE,iBAAiB,EAClC,KAAK,EAAE,QAAQ,GACd,MAAM,CAER;AAED,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,QAAQ,EACnD,eAAe,EAAE,iBAAiB,EAClC,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,OAAO,CAAC,MAAM,oBAAoB,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,GACvD,MAAM,CAER;AAED;;;;;;;;GAQG;AAEH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,gBAAgB,EAC5B,MAAM,EAAE,qBAAqB,GAC5B,IAAI,CAgBN"}

package/dist/better-auth/plugin/lib/build-collections/utils/collection-schema.js

@@ -0,0 +1,24 @@
+import { flattenAllFields } from "payload";
+export function getSchemaCollectionSlug(resolvedSchemas, model) {
+    return resolvedSchemas?.[model]?.modelName ?? model;
+}
+export function getSchemaFieldName(resolvedSchemas, model, fieldKey) {
+    return resolvedSchemas?.[model]?.fields?.[fieldKey]?.fieldName ?? fieldKey;
+}
+/**
+ * Asserts that all field keys that exist in the schema exist in the collection
+ *
+ * It checks based on the custom.betterAuthFieldKey property.
+ *
+ * @param collection - The collection object
+ * @param schema - The schema object containing field definitions
+ * @throws {Error} If any required field is missing from the schema
+ */ export function assertAllSchemaFields(collection, schema) {
+    const schemaFieldKeys = Object.keys(schema.fields);
+    const collectionConfigBetterAuthKeys = new Set(flattenAllFields(collection).map((field)=>field.custom?.betterAuthFieldKey).filter((key)=>typeof key === "string"));
+    const missingFields = schemaFieldKeys.filter((key)=>!collectionConfigBetterAuthKeys.has(key));
+    if (missingFields.length === 0) return;
+    throw new Error(`Missing required custom.betterAuthFieldKeys in collection "${collection.slug}": ${missingFields.join(", ")}`);
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9iZXR0ZXItYXV0aC9wbHVnaW4vbGliL2J1aWxkLWNvbGxlY3Rpb25zL3V0aWxzL2NvbGxlY3Rpb24tc2NoZW1hLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHR5cGUgQ29sbGVjdGlvbkNvbmZpZywgZmxhdHRlbkFsbEZpZWxkcyB9IGZyb20gXCJwYXlsb2FkXCI7XG5pbXBvcnQgdHlwZSB7XG4gIEJldHRlckF1dGhGdWxsU2NoZW1hLFxuICBNb2RlbEtleVxufSBmcm9tIFwiQC9iZXR0ZXItYXV0aC9nZW5lcmF0ZWQtdHlwZXNcIjtcbmltcG9ydCB0eXBlIHtcbiAgQmV0dGVyQXV0aFNjaGVtYXMsXG4gIEJ1aWx0QmV0dGVyQXV0aFNjaGVtYVxufSBmcm9tIFwiQC9iZXR0ZXItYXV0aC90eXBlc1wiO1xuXG5leHBvcnQgZnVuY3Rpb24gZ2V0U2NoZW1hQ29sbGVjdGlvblNsdWcoXG4gIHJlc29sdmVkU2NoZW1hczogQmV0dGVyQXV0aFNjaGVtYXMsXG4gIG1vZGVsOiBNb2RlbEtleVxuKTogc3RyaW5nIHtcbiAgcmV0dXJuIHJlc29sdmVkU2NoZW1hcz8uW21vZGVsXT8ubW9kZWxOYW1lID8/IG1vZGVsO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gZ2V0U2NoZW1hRmllbGROYW1lPE0gZXh0ZW5kcyBNb2RlbEtleT4oXG4gIHJlc29sdmVkU2NoZW1hczogQmV0dGVyQXV0aFNjaGVtYXMsXG4gIG1vZGVsOiBNLFxuICBmaWVsZEtleTogRXh0cmFjdDxrZXlvZiBCZXR0ZXJBdXRoRnVsbFNjaGVtYVtNXSwgc3RyaW5nPlxuKTogc3RyaW5nIHtcbiAgcmV0dXJuIHJlc29sdmVkU2NoZW1hcz8uW21vZGVsXT8uZmllbGRzPy5bZmllbGRLZXldPy5maWVsZE5hbWUgPz8gZmllbGRLZXk7XG59XG5cbi8qKlxuICogQXNzZXJ0cyB0aGF0IGFsbCBmaWVsZCBrZXlzIHRoYXQgZXhpc3QgaW4gdGhlIHNjaGVtYSBleGlzdCBpbiB0aGUgY29sbGVjdGlvblxuICpcbiAqIEl0IGNoZWNrcyBiYXNlZCBvbiB0aGUgY3VzdG9tLmJldHRlckF1dGhGaWVsZEtleSBwcm9wZXJ0eS5cbiAqXG4gKiBAcGFyYW0gY29sbGVjdGlvbiAtIFRoZSBjb2xsZWN0aW9uIG9iamVjdFxuICogQHBhcmFtIHNjaGVtYSAtIFRoZSBzY2hlbWEgb2JqZWN0IGNvbnRhaW5pbmcgZmllbGQgZGVmaW5pdGlvbnNcbiAqIEB0aHJvd3Mge0Vycm9yfSBJZiBhbnkgcmVxdWlyZWQgZmllbGQgaXMgbWlzc2luZyBmcm9tIHRoZSBzY2hlbWFcbiAqL1xuXG5leHBvcnQgZnVuY3Rpb24gYXNzZXJ0QWxsU2NoZW1hRmllbGRzKFxuICBjb2xsZWN0aW9uOiBDb2xsZWN0aW9uQ29uZmlnLFxuICBzY2hlbWE6IEJ1aWx0QmV0dGVyQXV0aFNjaGVtYVxuKTogdm9pZCB7XG4gIGNvbnN0IHNjaGVtYUZpZWxkS2V5cyA9IE9iamVjdC5rZXlzKHNjaGVtYS5maWVsZHMpO1xuICBjb25zdCBjb2xsZWN0aW9uQ29uZmlnQmV0dGVyQXV0aEtleXMgPSBuZXcgU2V0KFxuICAgIGZsYXR0ZW5BbGxGaWVsZHMoY29sbGVjdGlvbilcbiAgICAgIC5tYXAoKGZpZWxkKSA9PiBmaWVsZC5jdXN0b20/LmJldHRlckF1dGhGaWVsZEtleSlcbiAgICAgIC5maWx0ZXIoKGtleSk6IGtleSBpcyBzdHJpbmcgPT4gdHlwZW9mIGtleSA9PT0gXCJzdHJpbmdcIilcbiAgKTtcblxuICBjb25zdCBtaXNzaW5nRmllbGRzID0gc2NoZW1hRmllbGRLZXlzLmZpbHRlcihcbiAgICAoa2V5KSA9PiAhY29sbGVjdGlvbkNvbmZpZ0JldHRlckF1dGhLZXlzLmhhcyhrZXkpXG4gICk7XG4gIGlmIChtaXNzaW5nRmllbGRzLmxlbmd0aCA9PT0gMCkgcmV0dXJuO1xuXG4gIHRocm93IG5ldyBFcnJvcihcbiAgICBgTWlzc2luZyByZXF1aXJlZCBjdXN0b20uYmV0dGVyQXV0aEZpZWxkS2V5cyBpbiBjb2xsZWN0aW9uIFwiJHtjb2xsZWN0aW9uLnNsdWd9XCI6ICR7bWlzc2luZ0ZpZWxkcy5qb2luKFwiLCBcIil9YFxuICApO1xufVxuIl0sIm5hbWVzIjpbImZsYXR0ZW5BbGxGaWVsZHMiLCJnZXRTY2hlbWFDb2xsZWN0aW9uU2x1ZyIsInJlc29sdmVkU2NoZW1hcyIsIm1vZGVsIiwibW9kZWxOYW1lIiwiZ2V0U2NoZW1hRmllbGROYW1lIiwiZmllbGRLZXkiLCJmaWVsZHMiLCJmaWVsZE5hbWUiLCJhc3NlcnRBbGxTY2hlbWFGaWVsZHMiLCJjb2xsZWN0aW9uIiwic2NoZW1hIiwic2NoZW1hRmllbGRLZXlzIiwiT2JqZWN0Iiwia2V5cyIsImNvbGxlY3Rpb25Db25maWdCZXR0ZXJBdXRoS2V5cyIsIlNldCIsIm1hcCIsImZpZWxkIiwiY3VzdG9tIiwiYmV0dGVyQXV0aEZpZWxkS2V5IiwiZmlsdGVyIiwia2V5IiwibWlzc2luZ0ZpZWxkcyIsImhhcyIsImxlbmd0aCIsIkVycm9yIiwic2x1ZyIsImpvaW4iXSwibWFwcGluZ3MiOiJBQUFBLFNBQWdDQSxnQkFBZ0IsUUFBUSxVQUFVO0FBVWxFLE9BQU8sU0FBU0Msd0JBQ2RDLGVBQWtDLEVBQ2xDQyxLQUFlO0lBRWYsT0FBT0QsaUJBQWlCLENBQUNDLE1BQU0sRUFBRUMsYUFBYUQ7QUFDaEQ7QUFFQSxPQUFPLFNBQVNFLG1CQUNkSCxlQUFrQyxFQUNsQ0MsS0FBUSxFQUNSRyxRQUF3RDtJQUV4RCxPQUFPSixpQkFBaUIsQ0FBQ0MsTUFBTSxFQUFFSSxRQUFRLENBQUNELFNBQVMsRUFBRUUsYUFBYUY7QUFDcEU7QUFFQTs7Ozs7Ozs7Q0FRQyxHQUVELE9BQU8sU0FBU0csc0JBQ2RDLFVBQTRCLEVBQzVCQyxNQUE2QjtJQUU3QixNQUFNQyxrQkFBa0JDLE9BQU9DLElBQUksQ0FBQ0gsT0FBT0osTUFBTTtJQUNqRCxNQUFNUSxpQ0FBaUMsSUFBSUMsSUFDekNoQixpQkFBaUJVLFlBQ2RPLEdBQUcsQ0FBQyxDQUFDQyxRQUFVQSxNQUFNQyxNQUFNLEVBQUVDLG9CQUM3QkMsTUFBTSxDQUFDLENBQUNDLE1BQXVCLE9BQU9BLFFBQVE7SUFHbkQsTUFBTUMsZ0JBQWdCWCxnQkFBZ0JTLE1BQU0sQ0FDMUMsQ0FBQ0MsTUFBUSxDQUFDUCwrQkFBK0JTLEdBQUcsQ0FBQ0Y7SUFFL0MsSUFBSUMsY0FBY0UsTUFBTSxLQUFLLEdBQUc7SUFFaEMsTUFBTSxJQUFJQyxNQUNSLENBQUMsMkRBQTJELEVBQUVoQixXQUFXaUIsSUFBSSxDQUFDLEdBQUcsRUFBRUosY0FBY0ssSUFBSSxDQUFDLE9BQU87QUFFakgifQ==

package/dist/better-auth/plugin/lib/build-collections/utils/filter-properties.d.ts

@@ -0,0 +1,11 @@
+import type { Field } from "payload";
+export declare const COMMON_FIELD_KEYS: readonly ["access", "admin", "custom", "defaultValue", "hidden", "hooks", "index", "label", "localized", "name", "required", "saveToJWT", "typescriptSchema", "unique", "validate", "virtual", "_sanitized"];
+export declare const TEXT_FIELD_KEYS: readonly ["access", "admin", "custom", "defaultValue", "hidden", "hooks", "index", "label", "localized", "name", "required", "saveToJWT", "typescriptSchema", "unique", "validate", "virtual", "_sanitized", "type", "maxLength", "maxRows", "minLength", "minRows", "hasMany"];
+export declare const NUMBER_FIELD_KEYS: readonly ["access", "admin", "custom", "defaultValue", "hidden", "hooks", "index", "label", "localized", "name", "required", "saveToJWT", "typescriptSchema", "unique", "validate", "virtual", "_sanitized", "max", "min", "hasMany"];
+export declare const DATE_FIELD_KEYS: readonly ["access", "admin", "custom", "defaultValue", "hidden", "hooks", "index", "label", "localized", "name", "required", "saveToJWT", "typescriptSchema", "unique", "validate", "virtual", "_sanitized", "timezone"];
+export declare const CHECKBOX_FIELD_KEYS: readonly ["access", "admin", "custom", "defaultValue", "hidden", "hooks", "index", "label", "localized", "name", "required", "saveToJWT", "typescriptSchema", "unique", "validate", "virtual", "_sanitized"];
+export declare const RELATIONSHIP_FIELD_KEYS: readonly ["access", "admin", "custom", "defaultValue", "hidden", "hooks", "index", "label", "localized", "name", "required", "saveToJWT", "typescriptSchema", "unique", "validate", "virtual", "_sanitized", "filterOptions", "graphQL", "hasMany", "max", "maxDepth", "maxRows", "min", "minRows", "relationTo", "type"];
+export declare const SELECT_FIELD_KEYS: readonly ["access", "admin", "custom", "defaultValue", "hidden", "hooks", "index", "label", "localized", "name", "required", "saveToJWT", "typescriptSchema", "unique", "validate", "virtual", "_sanitized", "type", "options", "hasMany", "interfaceName", "enumName", "dbName", "validate", "defaultValue", "filterOptions"];
+export declare function getValidFieldPropertyKeysForType(type: Field["type"]): ("admin" | "validate" | "_sanitized" | "access" | "custom" | "defaultValue" | "hidden" | "hooks" | "index" | "label" | "localized" | "name" | "required" | "saveToJWT" | "typescriptSchema" | "unique" | "virtual" | "type" | "graphQL" | "relationTo" | "filterOptions" | "maxRows" | "minRows" | "maxDepth" | "hasMany" | "max" | "min")[] | ("admin" | "validate" | "_sanitized" | "access" | "custom" | "defaultValue" | "hidden" | "hooks" | "index" | "label" | "localized" | "name" | "required" | "saveToJWT" | "typescriptSchema" | "unique" | "virtual" | "type" | "maxRows" | "minRows" | "maxLength" | "minLength" | "hasMany")[] | ("admin" | "validate" | "_sanitized" | "access" | "custom" | "defaultValue" | "hidden" | "hooks" | "index" | "label" | "localized" | "name" | "required" | "saveToJWT" | "typescriptSchema" | "unique" | "virtual" | "timezone")[] | ("admin" | "validate" | "_sanitized" | "access" | "custom" | "defaultValue" | "hidden" | "hooks" | "index" | "label" | "localized" | "name" | "required" | "saveToJWT" | "typescriptSchema" | "unique" | "virtual" | "type" | "options" | "dbName" | "filterOptions" | "interfaceName" | "hasMany" | "enumName")[];
+export declare function filterProps<T extends object, K extends readonly (keyof T)[]>(obj: Partial<T>, allowed: K, extra?: readonly string[]): Partial<T>;
+//# sourceMappingURL=filter-properties.d.ts.map

package/dist/better-auth/plugin/lib/build-collections/utils/filter-properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-properties.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/lib/build-collections/utils/filter-properties.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,KAAK,EAMN,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,iBAAiB,8MAkBmB,CAAC;AAElD,eAAO,MAAM,eAAe,iRAQqB,CAAC;AAElD,eAAO,MAAM,iBAAiB,uOAKqB,CAAC;AAEpD,eAAO,MAAM,eAAe,0NAGqB,CAAC;AAElD,eAAO,MAAM,mBAAmB,8MAEqB,CAAC;AAEtD,eAAO,MAAM,uBAAuB,2TAYqB,CAAC;AAE1D,eAAO,MAAM,iBAAiB,gUAWqB,CAAC;AAEpD,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,2oCAiBnE;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,EAC1E,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,EACf,OAAO,EAAE,CAAC,EACV,KAAK,GAAE,SAAS,MAAM,EAAO,GAC5B,OAAO,CAAC,CAAC,CAAC,CAQZ"}

package/dist/better-auth/plugin/lib/build-collections/utils/filter-properties.js

@@ -0,0 +1,112 @@
+export const COMMON_FIELD_KEYS = [
+    "access",
+    "admin",
+    "custom",
+    "defaultValue",
+    "hidden",
+    "hooks",
+    "index",
+    "label",
+    "localized",
+    "name",
+    "required",
+    "saveToJWT",
+    "typescriptSchema",
+    "unique",
+    "validate",
+    "virtual",
+    "_sanitized"
+];
+export const TEXT_FIELD_KEYS = [
+    ...COMMON_FIELD_KEYS,
+    "type",
+    "maxLength",
+    "maxRows",
+    "minLength",
+    "minRows",
+    "hasMany"
+];
+export const NUMBER_FIELD_KEYS = [
+    ...COMMON_FIELD_KEYS,
+    "max",
+    "min",
+    "hasMany"
+];
+export const DATE_FIELD_KEYS = [
+    ...COMMON_FIELD_KEYS,
+    "timezone"
+];
+export const CHECKBOX_FIELD_KEYS = [
+    ...COMMON_FIELD_KEYS
+];
+export const RELATIONSHIP_FIELD_KEYS = [
+    ...COMMON_FIELD_KEYS,
+    "filterOptions",
+    "graphQL",
+    "hasMany",
+    "max",
+    "maxDepth",
+    "maxRows",
+    "min",
+    "minRows",
+    "relationTo",
+    "type"
+];
+export const SELECT_FIELD_KEYS = [
+    ...COMMON_FIELD_KEYS,
+    "type",
+    "options",
+    "hasMany",
+    "interfaceName",
+    "enumName",
+    "dbName",
+    "validate",
+    "defaultValue",
+    "filterOptions"
+];
+export function getValidFieldPropertyKeysForType(type) {
+    switch(type){
+        case "relationship":
+            return [
+                ...RELATIONSHIP_FIELD_KEYS
+            ];
+        case "text":
+            return [
+                ...TEXT_FIELD_KEYS
+            ];
+        case "number":
+            return [
+                ...NUMBER_FIELD_KEYS
+            ];
+        case "date":
+            return [
+                ...DATE_FIELD_KEYS
+            ];
+        case "checkbox":
+            return [
+                ...CHECKBOX_FIELD_KEYS
+            ];
+        case "select":
+            return [
+                ...SELECT_FIELD_KEYS
+            ];
+        default:
+            return [
+                ...COMMON_FIELD_KEYS
+            ];
+    }
+}
+export function filterProps(obj, allowed, extra = []) {
+    const allow = new Set([
+        ...allowed.map(String),
+        ...extra
+    ]);
+    const out = {};
+    for (const [k, v] of Object.entries(obj)){
+        if (!allow.has(k)) continue;
+        out[k] = v;
+    }
+    return out;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/lib/build-collections/utils/get-timestamp-fields.d.ts

@@ -0,0 +1,8 @@
+import type { Field } from "payload";
+interface GetTimestampFieldsOptions {
+    saveUpdatedAtToJWT?: boolean;
+    saveCreatedAtToJWT?: boolean;
+}
+export declare function getTimestampFields(options?: GetTimestampFieldsOptions): Field[];
+export {};
+//# sourceMappingURL=get-timestamp-fields.d.ts.map

package/dist/better-auth/plugin/lib/build-collections/utils/get-timestamp-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-timestamp-fields.d.ts","sourceRoot":"","sources":["../../../../../../src/better-auth/plugin/lib/build-collections/utils/get-timestamp-fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC,UAAU,yBAAyB;IACjC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,wBAAgB,kBAAkB,CAChC,OAAO,GAAE,yBAGR,GACA,KAAK,EAAE,CAyBT"}

package/dist/better-auth/plugin/lib/build-collections/utils/get-timestamp-fields.js

@@ -0,0 +1,31 @@
+export function getTimestampFields(options = {
+    saveUpdatedAtToJWT: true,
+    saveCreatedAtToJWT: true
+}) {
+    return [
+        {
+            name: "updatedAt",
+            type: "date",
+            saveToJWT: options.saveUpdatedAtToJWT,
+            admin: {
+                disableBulkEdit: true,
+                hidden: true
+            },
+            index: true,
+            label: ({ t })=>t("general:updatedAt")
+        },
+        {
+            name: "createdAt",
+            saveToJWT: options.saveCreatedAtToJWT,
+            admin: {
+                disableBulkEdit: true,
+                hidden: true
+            },
+            type: "date",
+            index: true,
+            label: ({ t })=>t("general:createdAt")
+        }
+    ];
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/plugin/lib/build-collections/utils/model-field-transformations.d.ts

@@ -0,0 +1,12 @@
+import type { DBFieldAttribute } from "better-auth/db";
+import type { Field } from "payload";
+import { FieldRule } from "@/better-auth/plugin/types";
+export declare const getAdditionalFieldProperties: ({ field, fieldKey, fieldRules, additionalProperties }: {
+    field: DBFieldAttribute;
+    fieldKey: string;
+    fieldRules?: FieldRule[];
+    additionalProperties?: {
+        [key: string]: (field: DBFieldAttribute) => Partial<Field>;
+    };
+}) => Partial<Field>;
+//# sourceMappingURL=model-field-transformations.d.ts.map