payload-auth 1.4.1 → 1.5.0

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

@@ -0,0 +1,108 @@
+import { baModelFieldKeysToFieldNames, baModelKey } from "../constants";
+import { getAuthTables } from "better-auth/db";
+import { flattenAllFields } from "payload/shared";
+import { getDeafultCollectionSlug } from "./get-collection-slug";
+export function getDefaultCollectionSchemaMap(pluginOptions) {
+    const tables = getAuthTables(pluginOptions.betterAuthOptions ?? {});
+    const map = {};
+    Object.entries(tables).forEach(([key, table])=>{
+        const fieldNames = Object.entries(table.fields).map(([k, v])=>k);
+        const typedKey = key;
+        const value = {
+            collectionSlug: getDeafultCollectionSlug({
+                modelKey: typedKey,
+                pluginOptions
+            }),
+            fields: fieldNames.reduce((acc, field)=>{
+                if (typedKey in baModelFieldKeysToFieldNames && field in baModelFieldKeysToFieldNames[typedKey]) {
+                    const fieldMapping = baModelFieldKeysToFieldNames[typedKey];
+                    const typedField = field;
+                    acc[field] = fieldMapping[typedField] || field;
+                } else {
+                    acc[field] = field;
+                }
+                return acc;
+            }, {})
+        };
+        map[typedKey] = value;
+    });
+    // always add the role field to the user collection if not already present
+    if (!map[baModelKey.user].fields.role) {
+        map[baModelKey.user].fields.role = baModelFieldKeysToFieldNames.user.role;
+    }
+    return map;
+}
+/**
+ * Builds a collection schema map by analyzing collection overrides and extracting
+ * BetterAuth model keys and field mappings
+ *
+ * @param collectionOverrides - Collection override functions provided in plugin options
+ * @returns A collection schema map with default values merged with any overrides
+ */ export function buildCollectionSchemaMap(pluginOptions) {
+    const collectionOverrides = {
+        users: pluginOptions.users?.collectionOverrides,
+        accounts: pluginOptions.accounts?.collectionOverrides,
+        sessions: pluginOptions.sessions?.collectionOverrides,
+        verifications: pluginOptions.verifications?.collectionOverrides,
+        ...pluginOptions.pluginCollectionOverrides
+    };
+    const defaultCollectionSchemaMap = getDefaultCollectionSchemaMap(pluginOptions);
+    if (!collectionOverrides || Object.keys(collectionOverrides).length === 0) {
+        return {
+            ...defaultCollectionSchemaMap
+        };
+    }
+    const schemaMap = {
+        ...defaultCollectionSchemaMap
+    };
+    Object.entries(collectionOverrides).forEach(([collectionSlug, overrideFunction])=>{
+        if (!overrideFunction) return;
+        const modifiedCollection = overrideFunction({
+            collection: {
+                slug: collectionSlug,
+                fields: []
+            }
+        });
+        const modelKey = assertModelKey(modifiedCollection);
+        schemaMap[modelKey].collectionSlug = modifiedCollection.slug;
+        const flattenedFields = flattenAllFields(modifiedCollection);
+        if (flattenedFields && Array.isArray(flattenedFields)) {
+            flattenedFields.forEach((field)=>{
+                // we only want to process fields that have a betterAuthFieldKey
+                // because its possible the user has added additional fields
+                if (field.custom?.betterAuthFieldKey) {
+                    const fieldKey = assertFieldKey(field, modelKey, modifiedCollection.slug);
+                    schemaMap[modelKey].fields[fieldKey] = field.name;
+                }
+            });
+        }
+    });
+    return schemaMap;
+}
+function assertFieldKey(field, modelKey, collectionSlug) {
+    const fieldKey = field.custom?.betterAuthFieldKey;
+    // Assert that fieldKey is a valid key in the baModelFieldKeysToFieldNames mapping
+    if (!Object.values(baModelFieldKeysToFieldNames).some((fieldMap)=>Object.keys(fieldMap).includes(fieldKey))) {
+        throw new Error(`Invalid custom.betterAuthFieldKey: ${fieldKey} for field ${field.name} in collection ${collectionSlug}, 
+        must be one of ${Object.keys(baModelFieldKeysToFieldNames[modelKey]).join(', ')}`);
+    }
+    return fieldKey;
+}
+/**
+ * Asserts that a collection has a valid BetterAuth model key and returns it
+ *
+ * @param collection - The collection to check for a BetterAuth model key
+ * @returns The BetterAuth model key
+ * @throws Error if the collection does not have a valid BetterAuth model key
+ */ function assertModelKey(collection) {
+    if (!collection.custom?.betterAuthModelKey) {
+        throw new Error(`Collection ${collection.slug} is missing a betterAuthModelKey in its custom field`);
+    }
+    const modelKey = collection.custom.betterAuthModelKey;
+    if (!Object.values(baModelKey).includes(modelKey)) {
+        throw new Error(`Collection ${collection.slug} has an invalid betterAuthModelKey: ${modelKey}`);
+    }
+    return modelKey;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/better-auth/plugin/helpers/get-collection-schema-map.ts"],"sourcesContent":["import { baModelFieldKeysToFieldNames, baModelKey } from '../constants'\nimport { getAuthTables } from 'better-auth/db'\nimport { BetterAuthOptions } from 'better-auth/types'\nimport { baModelKeyToSlug } from '../constants'\nimport { FlattenedField } from 'payload'\nimport { flattenAllFields } from 'payload/shared'\nimport { CollectionConfig } from 'payload'\nimport { getDeafultCollectionSlug } from './get-collection-slug'\nimport { BetterAuthPluginOptions } from '../types'\n\nexport type CollectionSchemaMap = Record<\n  keyof typeof baModelKey,\n  {\n    collectionSlug: string\n    fields: Record<string, string>\n  }\n>\n\nexport function getDefaultCollectionSchemaMap(pluginOptions: BetterAuthPluginOptions): CollectionSchemaMap {\n  const tables = getAuthTables(pluginOptions.betterAuthOptions ?? {})\n  const map = {} as CollectionSchemaMap\n  Object.entries(tables).forEach(([key, table]) => {\n    const fieldNames = Object.entries(table.fields).map(([k, v]) => k)\n    const typedKey = key as keyof typeof baModelKeyToSlug\n    const value = {\n      collectionSlug: getDeafultCollectionSlug({ modelKey: typedKey, pluginOptions }),\n      fields: fieldNames.reduce(\n        (acc, field) => {\n          if (\n            typedKey in baModelFieldKeysToFieldNames &&\n            field in baModelFieldKeysToFieldNames[typedKey as keyof typeof baModelFieldKeysToFieldNames]\n          ) {\n            const fieldMapping = baModelFieldKeysToFieldNames[typedKey as keyof typeof baModelFieldKeysToFieldNames]\n            const typedField = field as keyof typeof fieldMapping\n            acc[field] = fieldMapping[typedField] || field\n          } else {\n            acc[field] = field\n          }\n          return acc\n        },\n        {} as Record<string, string>\n      )\n    }\n\n    map[typedKey] = value\n  })\n\n  // always add the role field to the user collection if not already present\n  if (!map[baModelKey.user].fields.role) {\n    map[baModelKey.user].fields.role = baModelFieldKeysToFieldNames.user.role\n  }\n\n  return map\n}\n\ntype CollectionOverride = ((options: { collection: CollectionConfig }) => CollectionConfig) | undefined\n\ntype CollectionOverrides = Record<string, CollectionOverride>\n\n/**\n * Builds a collection schema map by analyzing collection overrides and extracting\n * BetterAuth model keys and field mappings\n *\n * @param collectionOverrides - Collection override functions provided in plugin options\n * @returns A collection schema map with default values merged with any overrides\n */\nexport function buildCollectionSchemaMap(pluginOptions: BetterAuthPluginOptions): CollectionSchemaMap {\n  const collectionOverrides = {\n    users: pluginOptions.users?.collectionOverrides,\n    accounts: pluginOptions.accounts?.collectionOverrides,\n    sessions: pluginOptions.sessions?.collectionOverrides,\n    verifications: pluginOptions.verifications?.collectionOverrides,\n    ...pluginOptions.pluginCollectionOverrides\n  }\n\n  const defaultCollectionSchemaMap = getDefaultCollectionSchemaMap(pluginOptions)\n\n  if (!collectionOverrides || Object.keys(collectionOverrides).length === 0) {\n    return { ...defaultCollectionSchemaMap }\n  }\n\n  const schemaMap = { ...defaultCollectionSchemaMap }\n\n  Object.entries(collectionOverrides).forEach(([collectionSlug, overrideFunction]) => {\n    if (!overrideFunction) return\n\n    const modifiedCollection = overrideFunction({\n      collection: {\n        slug: collectionSlug,\n        fields: []\n      }\n    })\n    const modelKey = assertModelKey(modifiedCollection)\n    schemaMap[modelKey].collectionSlug = modifiedCollection.slug\n    const flattenedFields = flattenAllFields(modifiedCollection)\n    if (flattenedFields && Array.isArray(flattenedFields)) {\n      flattenedFields.forEach((field: FlattenedField) => {\n        // we only want to process fields that have a betterAuthFieldKey\n        // because its possible the user has added additional fields\n        if (field.custom?.betterAuthFieldKey) {\n          const fieldKey = assertFieldKey(field, modelKey, modifiedCollection.slug)\n          schemaMap[modelKey].fields[fieldKey] = field.name\n        }\n      })\n    }\n  })\n\n  return schemaMap\n}\n\nfunction assertFieldKey(field: FlattenedField, modelKey: keyof typeof baModelKey, collectionSlug: string) {\n  const fieldKey = field.custom?.betterAuthFieldKey as string\n\n  // Assert that fieldKey is a valid key in the baModelFieldKeysToFieldNames mapping\n  if (!Object.values(baModelFieldKeysToFieldNames).some((fieldMap) => Object.keys(fieldMap).includes(fieldKey))) {\n    throw new Error(\n      `Invalid custom.betterAuthFieldKey: ${fieldKey} for field ${field.name} in collection ${collectionSlug}, \n        must be one of ${Object.keys(baModelFieldKeysToFieldNames[modelKey as keyof typeof baModelFieldKeysToFieldNames]).join(', ')}`\n    )\n  }\n\n  return fieldKey\n}\n\n/**\n * Asserts that a collection has a valid BetterAuth model key and returns it\n *\n * @param collection - The collection to check for a BetterAuth model key\n * @returns The BetterAuth model key\n * @throws Error if the collection does not have a valid BetterAuth model key\n */\nfunction assertModelKey(collection: CollectionConfig): keyof typeof baModelKey {\n  if (!collection.custom?.betterAuthModelKey) {\n    throw new Error(`Collection ${collection.slug} is missing a betterAuthModelKey in its custom field`)\n  }\n\n  const modelKey = collection.custom.betterAuthModelKey as keyof typeof baModelKey\n\n  if (!Object.values(baModelKey).includes(modelKey as any)) {\n    throw new Error(`Collection ${collection.slug} has an invalid betterAuthModelKey: ${modelKey}`)\n  }\n\n  return modelKey\n}\n"],"names":["baModelFieldKeysToFieldNames","baModelKey","getAuthTables","flattenAllFields","getDeafultCollectionSlug","getDefaultCollectionSchemaMap","pluginOptions","tables","betterAuthOptions","map","Object","entries","forEach","key","table","fieldNames","fields","k","v","typedKey","value","collectionSlug","modelKey","reduce","acc","field","fieldMapping","typedField","user","role","buildCollectionSchemaMap","collectionOverrides","users","accounts","sessions","verifications","pluginCollectionOverrides","defaultCollectionSchemaMap","keys","length","schemaMap","overrideFunction","modifiedCollection","collection","slug","assertModelKey","flattenedFields","Array","isArray","custom","betterAuthFieldKey","fieldKey","assertFieldKey","name","values","some","fieldMap","includes","Error","join","betterAuthModelKey"],"mappings":"AAAA,SAASA,4BAA4B,EAAEC,UAAU,QAAQ,eAAc;AACvE,SAASC,aAAa,QAAQ,iBAAgB;AAI9C,SAASC,gBAAgB,QAAQ,iBAAgB;AAEjD,SAASC,wBAAwB,QAAQ,wBAAuB;AAWhE,OAAO,SAASC,8BAA8BC,aAAsC;IAClF,MAAMC,SAASL,cAAcI,cAAcE,iBAAiB,IAAI,CAAC;IACjE,MAAMC,MAAM,CAAC;IACbC,OAAOC,OAAO,CAACJ,QAAQK,OAAO,CAAC,CAAC,CAACC,KAAKC,MAAM;QAC1C,MAAMC,aAAaL,OAAOC,OAAO,CAACG,MAAME,MAAM,EAAEP,GAAG,CAAC,CAAC,CAACQ,GAAGC,EAAE,GAAKD;QAChE,MAAME,WAAWN;QACjB,MAAMO,QAAQ;YACZC,gBAAgBjB,yBAAyB;gBAAEkB,UAAUH;gBAAUb;YAAc;YAC7EU,QAAQD,WAAWQ,MAAM,CACvB,CAACC,KAAKC;gBACJ,IACEN,YAAYnB,gCACZyB,SAASzB,4BAA4B,CAACmB,SAAsD,EAC5F;oBACA,MAAMO,eAAe1B,4BAA4B,CAACmB,SAAsD;oBACxG,MAAMQ,aAAaF;oBACnBD,GAAG,CAACC,MAAM,GAAGC,YAAY,CAACC,WAAW,IAAIF;gBAC3C,OAAO;oBACLD,GAAG,CAACC,MAAM,GAAGA;gBACf;gBACA,OAAOD;YACT,GACA,CAAC;QAEL;QAEAf,GAAG,CAACU,SAAS,GAAGC;IAClB;IAEA,0EAA0E;IAC1E,IAAI,CAACX,GAAG,CAACR,WAAW2B,IAAI,CAAC,CAACZ,MAAM,CAACa,IAAI,EAAE;QACrCpB,GAAG,CAACR,WAAW2B,IAAI,CAAC,CAACZ,MAAM,CAACa,IAAI,GAAG7B,6BAA6B4B,IAAI,CAACC,IAAI;IAC3E;IAEA,OAAOpB;AACT;AAMA;;;;;;CAMC,GACD,OAAO,SAASqB,yBAAyBxB,aAAsC;IAC7E,MAAMyB,sBAAsB;QAC1BC,OAAO1B,cAAc0B,KAAK,EAAED;QAC5BE,UAAU3B,cAAc2B,QAAQ,EAAEF;QAClCG,UAAU5B,cAAc4B,QAAQ,EAAEH;QAClCI,eAAe7B,cAAc6B,aAAa,EAAEJ;QAC5C,GAAGzB,cAAc8B,yBAAyB;IAC5C;IAEA,MAAMC,6BAA6BhC,8BAA8BC;IAEjE,IAAI,CAACyB,uBAAuBrB,OAAO4B,IAAI,CAACP,qBAAqBQ,MAAM,KAAK,GAAG;QACzE,OAAO;YAAE,GAAGF,0BAA0B;QAAC;IACzC;IAEA,MAAMG,YAAY;QAAE,GAAGH,0BAA0B;IAAC;IAElD3B,OAAOC,OAAO,CAACoB,qBAAqBnB,OAAO,CAAC,CAAC,CAACS,gBAAgBoB,iBAAiB;QAC7E,IAAI,CAACA,kBAAkB;QAEvB,MAAMC,qBAAqBD,iBAAiB;YAC1CE,YAAY;gBACVC,MAAMvB;gBACNL,QAAQ,EAAE;YACZ;QACF;QACA,MAAMM,WAAWuB,eAAeH;QAChCF,SAAS,CAAClB,SAAS,CAACD,cAAc,GAAGqB,mBAAmBE,IAAI;QAC5D,MAAME,kBAAkB3C,iBAAiBuC;QACzC,IAAII,mBAAmBC,MAAMC,OAAO,CAACF,kBAAkB;YACrDA,gBAAgBlC,OAAO,CAAC,CAACa;gBACvB,gEAAgE;gBAChE,4DAA4D;gBAC5D,IAAIA,MAAMwB,MAAM,EAAEC,oBAAoB;oBACpC,MAAMC,WAAWC,eAAe3B,OAAOH,UAAUoB,mBAAmBE,IAAI;oBACxEJ,SAAS,CAAClB,SAAS,CAACN,MAAM,CAACmC,SAAS,GAAG1B,MAAM4B,IAAI;gBACnD;YACF;QACF;IACF;IAEA,OAAOb;AACT;AAEA,SAASY,eAAe3B,KAAqB,EAAEH,QAAiC,EAAED,cAAsB;IACtG,MAAM8B,WAAW1B,MAAMwB,MAAM,EAAEC;IAE/B,kFAAkF;IAClF,IAAI,CAACxC,OAAO4C,MAAM,CAACtD,8BAA8BuD,IAAI,CAAC,CAACC,WAAa9C,OAAO4B,IAAI,CAACkB,UAAUC,QAAQ,CAACN,YAAY;QAC7G,MAAM,IAAIO,MACR,CAAC,mCAAmC,EAAEP,SAAS,WAAW,EAAE1B,MAAM4B,IAAI,CAAC,eAAe,EAAEhC,eAAe;uBACtF,EAAEX,OAAO4B,IAAI,CAACtC,4BAA4B,CAACsB,SAAsD,EAAEqC,IAAI,CAAC,OAAO;IAEpI;IAEA,OAAOR;AACT;AAEA;;;;;;CAMC,GACD,SAASN,eAAeF,UAA4B;IAClD,IAAI,CAACA,WAAWM,MAAM,EAAEW,oBAAoB;QAC1C,MAAM,IAAIF,MAAM,CAAC,WAAW,EAAEf,WAAWC,IAAI,CAAC,oDAAoD,CAAC;IACrG;IAEA,MAAMtB,WAAWqB,WAAWM,MAAM,CAACW,kBAAkB;IAErD,IAAI,CAAClD,OAAO4C,MAAM,CAACrD,YAAYwD,QAAQ,CAACnC,WAAkB;QACxD,MAAM,IAAIoC,MAAM,CAAC,WAAW,EAAEf,WAAWC,IAAI,CAAC,oCAAoC,EAAEtB,UAAU;IAChG;IAEA,OAAOA;AACT"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-collection-slug.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/get-collection-slug.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAGvD,wBAAgB,wBAAwB,CAAC,EACvC,aAAa,EACb,QAAQ,EACT,EAAE;IACD,aAAa,EAAE,uBAAuB,CAAA;IACtC,QAAQ,EAAE,MAAM,CAAA;CACjB,GAAG,MAAM,CAiBT"}

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

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

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

@@ -0,0 +1,41 @@
+import type { Collection, CollectionConfig, Field } from 'payload';
+/**
+ * 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 declare function getMappedCollection({ collectionMap, betterAuthModelKey }: {
+    collectionMap: Record<string, CollectionConfig>;
+    betterAuthModelKey: string;
+}): CollectionConfig;
+interface MappedField extends Omit<Field, 'type'> {
+    name: string;
+    type: Exclude<Field['type'], 'tabs' | 'row' | 'collapsible'>;
+}
+/**
+ * Retrieves a field from a collection based on its Better Auth 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.
+ *
+ * @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 declare function getMappedField({ collection, betterAuthFieldKey }: {
+    collection: CollectionConfig;
+    betterAuthFieldKey: string;
+}): MappedField;
+export declare function transformCollectionsToCollectionConfigs(collections: Record<string, Collection>): Record<string, CollectionConfig>;
+export {};
+//# sourceMappingURL=get-collection.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,62 @@
+/**
+ * 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;
+    });
+    // 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;
+    }
+    return collection;
+}
+/**
+ * Retrieves a field from a collection based on its Better Auth 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.
+ *
+ * @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
+        ]));
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,13 +1,8 @@
 import { Session, User } from 'better-auth';
-import type { Config, Payload } from 'payload';
-type CollectionSlugs = {
-    userCollectionSlug: string;
-    sessionCollectionSlug: string;
-};
-export declare function prepareUser({ user, payloadConfig, collectionSlugs }: {
+import type { CollectionConfig } from 'payload';
+export declare function prepareUser({ user, userCollection }: {
     user: User & Record<string, any>;
-    payloadConfig: Payload['config'] | Config | Promise<Payload['config'] | Config>;
-    collectionSlugs: CollectionSlugs;
+    userCollection: CollectionConfig;
 }): Promise<{
     id: string;
     name: string;
@@ -17,11 +12,9 @@ export declare function prepareUser({ user, payloadConfig, collectionSlugs }: {
     updatedAt: Date;
     image?: string | null | undefined;
 } & Record<string, any>>;
-export declare function prepareSession({ user, session, payloadConfig, collectionSlugs }: {
-    user: User & Record<string, any>;
+export declare function prepareSession({ session, sessionCollection }: {
     session: Session & Record<string, any>;
-    payloadConfig: Payload['config'] | Config | Promise<Payload['config'] | Config>;
-    collectionSlugs: CollectionSlugs;
+    sessionCollection: CollectionConfig;
 }): Promise<{
     id: string;
     createdAt: Date;
@@ -36,13 +29,13 @@ export declare function prepareSession({ user, session, payloadConfig, collectio
  * Prepares session data for cookie cache by filtering user and session objects
  * based on the payload configuration's 'saveToJwt' property
  */
-export declare function prepareSessionData({ sessionData, payloadConfig, collectionSlugs }: {
+export declare function prepareSessionData({ sessionData, usersCollection, sessionsCollection }: {
     sessionData: {
         session: Session & Record<string, any>;
         user: User & Record<string, any>;
     };
-    payloadConfig: Payload['config'] | Config | Promise<Payload['config'] | Config>;
-    collectionSlugs: CollectionSlugs;
+    usersCollection: CollectionConfig;
+    sessionsCollection: CollectionConfig;
 }): Promise<{
     session: {
         id: string;
@@ -64,5 +57,4 @@ export declare function prepareSessionData({ sessionData, payloadConfig, collect
         image?: string | null | undefined;
     } & Record<string, any>;
 } | null>;
-export {};
 //# sourceMappingURL=prepare-session-data.d.ts.map

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;AAE3C,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAE9C,KAAK,eAAe,GAAG;IACrB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,qBAAqB,EAAE,MAAM,CAAA;CAC9B,CAAA;AAED,wBAAsB,WAAW,CAAC,EAChC,IAAI,EACJ,aAAa,EACb,eAAe,EAChB,EAAE;IACD,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAChC,aAAa,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC,CAAA;IAC/E,eAAe,EAAE,eAAe,CAAA;CACjC;;;;;;;;yBAiBA;AAED,wBAAsB,cAAc,CAAC,EACnC,IAAI,EACJ,OAAO,EACP,aAAa,EACb,eAAe,EAChB,EAAE;IACD,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAChC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACtC,aAAa,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC,CAAA;IAC/E,eAAe,EAAE,eAAe,CAAA;CACjC;;;;;;;;;yBAuBA;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,EACvC,WAAW,EACX,aAAa,EACb,eAAe,EAChB,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,aAAa,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC,CAAA;IAC/E,eAAe,EAAE,eAAe,CAAA;CACjC;;;;;;;;;;;;;;;;;;;;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,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"}

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

@@ -1,30 +1,22 @@
 import { getFieldsToSign } from "payload";
-export async function prepareUser({ user, payloadConfig, collectionSlugs }) {
-    const awaitedPayloadConfig = await payloadConfig;
-    const { userCollectionSlug } = collectionSlugs;
-    const userCollection = awaitedPayloadConfig?.collections?.find((c)=>c.slug === userCollectionSlug);
-    if (!userCollection) throw new Error(`User collection with slug '${userCollectionSlug}' not found`);
+export async function prepareUser({ user, userCollection }) {
     const newUser = getFieldsToSign({
         collectionConfig: userCollection,
         email: user.email,
         user: {
             ...user,
-            collection: userCollectionSlug
+            collection: userCollection.slug
         }
     });
     return newUser;
 }
-export async function prepareSession({ user, session, payloadConfig, collectionSlugs }) {
-    const awaitedPayloadConfig = await payloadConfig;
-    const { sessionCollectionSlug, userCollectionSlug } = collectionSlugs;
-    const sessionCollection = awaitedPayloadConfig?.collections?.find((c)=>c.slug === sessionCollectionSlug);
-    if (!sessionCollection) return session;
+export async function prepareSession({ session, sessionCollection }) {
     const filteredSession = getFieldsToSign({
         collectionConfig: sessionCollection,
-        email: user.email,
+        email: '',
         user: {
             ...session,
-            collection: sessionCollectionSlug
+            collection: sessionCollection.slug
         }
     });
     delete filteredSession.email;
@@ -37,18 +29,15 @@ export async function prepareSession({ user, session, payloadConfig, collectionS
 /**
  * Prepares session data for cookie cache by filtering user and session objects
  * based on the payload configuration's 'saveToJwt' property
- */ export async function prepareSessionData({ sessionData, payloadConfig, collectionSlugs }) {
+ */ export async function prepareSessionData({ sessionData, usersCollection, sessionsCollection }) {
     if (!sessionData || !sessionData.user) return null;
     const newUser = await prepareUser({
         user: sessionData.user,
-        payloadConfig,
-        collectionSlugs
+        userCollection: usersCollection
     });
     const newSession = await prepareSession({
-        user: sessionData.user,
         session: sessionData.session,
-        payloadConfig,
-        collectionSlugs
+        sessionCollection: sessionsCollection
     });
     const newSessionData = {
         session: newSession,
@@ -57,4 +46,4 @@ export async function prepareSession({ user, session, payloadConfig, collectionS
     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/index.d.ts

@@ -1,8 +1,8 @@
-import type { Config } from 'payload';
+import { type Config } from 'payload';
 import type { BetterAuthPluginOptions } from './types';
-export { sanitizeBetterAuthOptions } from './lib/sanitize-better-auth-options/index';
+export * from './helpers/index';
 export { getPayloadAuth } from './lib/get-payload-auth';
+export { sanitizeBetterAuthOptions } from './lib/sanitize-better-auth-options/index';
 export * from './types';
-export * from './helpers/index';
 export declare function betterAuthPlugin(pluginOptions: BetterAuthPluginOptions): (config: Config) => Config;
 //# 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,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AACrC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAA;AAStD,OAAO,EAAE,yBAAyB,EAAE,MAAM,0CAA0C,CAAA;AACpF,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AACvD,cAAc,SAAS,CAAA;AACvB,cAAc,iBAAiB,CAAA;AAE/B,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,uBAAuB,IAC7D,QAAQ,MAAM,KAAG,MAAM,CAqJhC"}
+{"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"}