@revealui/auth 0.0.1-pre.0

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

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/better-auth/plugin/helpers/get-all-roles.ts"],"sourcesContent":["import type { BetterAuthPluginOptions } from '../types';\n\nexport function getAllRoleOptions(pluginOptions: BetterAuthPluginOptions) {\n  const adminRoles = pluginOptions.users?.adminRoles ?? ['admin'];\n  const roles = pluginOptions.users?.roles ?? ['user'];\n  const allRoleOptions = [...new Set([...adminRoles, ...roles])].map(role => ({\n    label: role\n      .split(/[-_\\s]/)\n      .map(word => word.charAt(0).toUpperCase() + word.slice(1))\n      .join(' '),\n    value: role,\n  }));\n  return allRoleOptions;\n}\n"],"names":["getAllRoleOptions","pluginOptions","adminRoles","users","roles","allRoleOptions","Set","map","role","label","split","word","charAt","toUpperCase","slice","join","value"],"mappings":"AAEA,OAAO,SAASA,kBAAkBC,aAAsC;IACtE,MAAMC,aAAaD,cAAcE,KAAK,EAAED,cAAc;QAAC;KAAQ;IAC/D,MAAME,QAAQH,cAAcE,KAAK,EAAEC,SAAS;QAAC;KAAO;IACpD,MAAMC,iBAAiB;WAAI,IAAIC,IAAI;eAAIJ;eAAeE;SAAM;KAAE,CAACG,GAAG,CAACC,CAAAA,OAAS,CAAA;YAC1EC,OAAOD,KACJE,KAAK,CAAC,UACNH,GAAG,CAACI,CAAAA,OAAQA,KAAKC,MAAM,CAAC,GAAGC,WAAW,KAAKF,KAAKG,KAAK,CAAC,IACtDC,IAAI,CAAC;YACRC,OAAOR;QACT,CAAA;IACA,OAAOH;AACT"}

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

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

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

@@ -0,0 +1,70 @@
+import { getAuthTables } from "better-auth/db";
+import { baModelFieldKeysToFieldNames } from "../constants";
+import { getDefaultCollectionSlug } from "./get-collection-slug";
+/**
+ * A consistent BetterAuth schema generator.
+ *
+ * Differences from the original `getSchema` implementation in BetterAuth:
+ * 1. Keys in the returned object are always the **static table identifiers** coming from
+ *    `getAuthTables`, never the possibly-overridden `modelName`.  This guarantees that
+ *    subsequent look-ups remain stable even if the user renames collections.
+ * 2. Each schema entry now contains an explicit `modelName` property exposing the current
+ *    (potentially user-overridden) model name, while `fields` continue to be referenced by
+ *    their static BetterAuth field keys.
+ * 3. When converting fields, we store them under their original key (`actualFields[key] = field`)
+ *    instead of `field.fieldName || key` to avoid accidental renames.
+ *
+ * @param config - The BetterAuth options fed into `getAuthTables`.
+ * @returns A map keyed by static table keys, each value containing `{ modelName, fields, order }`.
+ */ export function getDefaultBetterAuthSchema(pluginOptions) {
+    const betterAuthOptions = pluginOptions.betterAuthOptions ?? {};
+    const tables = getAuthTables(betterAuthOptions);
+    const schema = {};
+    for (const modelKey of Object.keys(tables)){
+        const table = tables[modelKey];
+        // Skip if table is undefined
+        if (!table) continue;
+        // Resolve the canonical collection slug / model name for this key
+        const resolvedModelName = getDefaultCollectionSlug({
+            modelKey,
+            pluginOptions
+        });
+        const defaultFieldMap = baModelFieldKeysToFieldNames[modelKey] ?? {};
+        const actualFields = {};
+        Object.entries(table.fields ?? {}).forEach(([fieldKey, fieldValue])=>{
+            // Build the field ensuring a fieldName exists
+            const newField = {
+                ...fieldValue,
+                fieldName: defaultFieldMap[fieldKey] ?? fieldKey
+            };
+            // Rewrite references to use the resolved modelName for the target table
+            if (fieldValue.references) {
+                const refModelKey = fieldValue.references.model;
+                const resolvedRefModelName = getDefaultCollectionSlug({
+                    modelKey: refModelKey,
+                    pluginOptions
+                });
+                newField.references = {
+                    field: fieldValue.references.field,
+                    model: resolvedRefModelName
+                };
+            }
+            actualFields[fieldKey] = newField;
+        });
+        if (schema[modelKey]) {
+            schema[modelKey].fields = {
+                ...schema[modelKey].fields,
+                ...actualFields
+            };
+            continue;
+        }
+        schema[modelKey] = {
+            fields: actualFields,
+            modelName: resolvedModelName,
+            order: table.order ?? Number.POSITIVE_INFINITY
+        };
+    }
+    return schema;
+}
+
+//# sourceMappingURL=get-better-auth-schema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/better-auth/plugin/helpers/get-better-auth-schema.ts"],"sourcesContent":["import type { ModelKey } from '@/better-auth/generated-types';\nimport { getAuthTables } from 'better-auth/db';\nimport type { DBFieldAttribute } from 'better-auth/db';\nimport type { BetterAuthOptions as BetterAuthOptionsType } from 'better-auth/types';\nimport { baModelFieldKeysToFieldNames } from '../constants';\nimport type { BetterAuthPluginOptions, BetterAuthSchemas } from '../types';\nimport { getDefaultCollectionSlug } from './get-collection-slug';\n\n/**\n * A consistent BetterAuth schema generator.\n *\n * Differences from the original `getSchema` implementation in BetterAuth:\n * 1. Keys in the returned object are always the **static table identifiers** coming from\n *    `getAuthTables`, never the possibly-overridden `modelName`.  This guarantees that\n *    subsequent look-ups remain stable even if the user renames collections.\n * 2. Each schema entry now contains an explicit `modelName` property exposing the current\n *    (potentially user-overridden) model name, while `fields` continue to be referenced by\n *    their static BetterAuth field keys.\n * 3. When converting fields, we store them under their original key (`actualFields[key] = field`)\n *    instead of `field.fieldName || key` to avoid accidental renames.\n *\n * @param config - The BetterAuth options fed into `getAuthTables`.\n * @returns A map keyed by static table keys, each value containing `{ modelName, fields, order }`.\n */\nexport function getDefaultBetterAuthSchema(\n  pluginOptions: BetterAuthPluginOptions\n): BetterAuthSchemas {\n  const betterAuthOptions = pluginOptions.betterAuthOptions ?? {};\n  const tables = getAuthTables(betterAuthOptions as BetterAuthOptionsType);\n\n  const schema: Partial<BetterAuthSchemas> = {};\n\n  for (const modelKey of Object.keys(tables) as ModelKey[]) {\n    const table = tables[modelKey];\n\n    // Skip if table is undefined\n    if (!table) continue;\n\n    // Resolve the canonical collection slug / model name for this key\n    const resolvedModelName = getDefaultCollectionSlug({ modelKey, pluginOptions });\n\n    const defaultFieldMap =\n      (baModelFieldKeysToFieldNames as Record<string, Record<string, string>>)[modelKey] ?? {};\n\n    const actualFields: Record<string, DBFieldAttribute> = {};\n\n    Object.entries(table.fields ?? {}).forEach(([fieldKey, fieldValue]) => {\n      // Build the field ensuring a fieldName exists\n      const newField: DBFieldAttribute = {\n        ...fieldValue,\n        fieldName: defaultFieldMap[fieldKey] ?? fieldKey,\n      };\n\n      // Rewrite references to use the resolved modelName for the target table\n      if (fieldValue.references) {\n        const refModelKey = fieldValue.references.model as string;\n        const resolvedRefModelName = getDefaultCollectionSlug({\n          modelKey: refModelKey,\n          pluginOptions,\n        });\n        newField.references = {\n          field: fieldValue.references.field,\n          model: resolvedRefModelName,\n        };\n      }\n\n      actualFields[fieldKey] = newField;\n    });\n\n    if (schema[modelKey]) {\n      schema[modelKey].fields = {\n        ...schema[modelKey].fields,\n        ...actualFields,\n      };\n      continue;\n    }\n\n    schema[modelKey] = {\n      fields: actualFields,\n      modelName: resolvedModelName,\n      order: table.order ?? Number.POSITIVE_INFINITY,\n    };\n  }\n\n  return schema as BetterAuthSchemas;\n}\n"],"names":["getAuthTables","baModelFieldKeysToFieldNames","getDefaultCollectionSlug","getDefaultBetterAuthSchema","pluginOptions","betterAuthOptions","tables","schema","modelKey","Object","keys","table","resolvedModelName","defaultFieldMap","actualFields","entries","fields","forEach","fieldKey","fieldValue","newField","fieldName","references","refModelKey","model","resolvedRefModelName","field","modelName","order","Number","POSITIVE_INFINITY"],"mappings":"AACA,SAASA,aAAa,QAAQ,iBAAiB;AAG/C,SAASC,4BAA4B,QAAQ,eAAe;AAE5D,SAASC,wBAAwB,QAAQ,wBAAwB;AAEjE;;;;;;;;;;;;;;;CAeC,GACD,OAAO,SAASC,2BACdC,aAAsC;IAEtC,MAAMC,oBAAoBD,cAAcC,iBAAiB,IAAI,CAAC;IAC9D,MAAMC,SAASN,cAAcK;IAE7B,MAAME,SAAqC,CAAC;IAE5C,KAAK,MAAMC,YAAYC,OAAOC,IAAI,CAACJ,QAAuB;QACxD,MAAMK,QAAQL,MAAM,CAACE,SAAS;QAE9B,6BAA6B;QAC7B,IAAI,CAACG,OAAO;QAEZ,kEAAkE;QAClE,MAAMC,oBAAoBV,yBAAyB;YAAEM;YAAUJ;QAAc;QAE7E,MAAMS,kBACJ,AAACZ,4BAAuE,CAACO,SAAS,IAAI,CAAC;QAEzF,MAAMM,eAAiD,CAAC;QAExDL,OAAOM,OAAO,CAACJ,MAAMK,MAAM,IAAI,CAAC,GAAGC,OAAO,CAAC,CAAC,CAACC,UAAUC,WAAW;YAChE,8CAA8C;YAC9C,MAAMC,WAA6B;gBACjC,GAAGD,UAAU;gBACbE,WAAWR,eAAe,CAACK,SAAS,IAAIA;YAC1C;YAEA,wEAAwE;YACxE,IAAIC,WAAWG,UAAU,EAAE;gBACzB,MAAMC,cAAcJ,WAAWG,UAAU,CAACE,KAAK;gBAC/C,MAAMC,uBAAuBvB,yBAAyB;oBACpDM,UAAUe;oBACVnB;gBACF;gBACAgB,SAASE,UAAU,GAAG;oBACpBI,OAAOP,WAAWG,UAAU,CAACI,KAAK;oBAClCF,OAAOC;gBACT;YACF;YAEAX,YAAY,CAACI,SAAS,GAAGE;QAC3B;QAEA,IAAIb,MAAM,CAACC,SAAS,EAAE;YACpBD,MAAM,CAACC,SAAS,CAACQ,MAAM,GAAG;gBACxB,GAAGT,MAAM,CAACC,SAAS,CAACQ,MAAM;gBAC1B,GAAGF,YAAY;YACjB;YACA;QACF;QAEAP,MAAM,CAACC,SAAS,GAAG;YACjBQ,QAAQF;YACRa,WAAWf;YACXgB,OAAOjB,MAAMiB,KAAK,IAAIC,OAAOC,iBAAiB;QAChD;IACF;IAEA,OAAOvB;AACT"}

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

@@ -0,0 +1,5 @@
+import type { BetterAuthPluginOptions } from '../types';
+export declare function getDefaultCollectionSlug({ pluginOptions, modelKey, }: {
+    pluginOptions: BetterAuthPluginOptions;
+    modelKey: string;
+}): string;

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

@@ -0,0 +1,20 @@
+import { baModelKeyToSlug, baseSlugs } from "../constants";
+export function getDefaultCollectionSlug({ pluginOptions, modelKey }) {
+    const baseSlug = baModelKeyToSlug[modelKey] ?? modelKey;
+    switch(modelKey){
+        case 'user':
+            return pluginOptions.users?.slug ?? baseSlugs.users;
+        case 'account':
+            return pluginOptions.accounts?.slug ?? baseSlugs.accounts;
+        case 'session':
+            return pluginOptions.sessions?.slug ?? baseSlugs.sessions;
+        case 'verification':
+            return pluginOptions.verifications?.slug ?? baseSlugs.verifications;
+        case 'adminInvitation':
+            return pluginOptions.adminInvitations?.slug ?? baseSlugs.adminInvitations;
+        default:
+            return baseSlug;
+    }
+}
+
+//# sourceMappingURL=get-collection-slug.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/better-auth/plugin/helpers/get-collection-slug.ts"],"sourcesContent":["import { baModelKeyToSlug, baseSlugs } from '../constants';\nimport type { BetterAuthPluginOptions } from '../types';\n\nexport function getDefaultCollectionSlug({\n  pluginOptions,\n  modelKey,\n}: {\n  pluginOptions: BetterAuthPluginOptions;\n  modelKey: string;\n}): string {\n  const baseSlug = baModelKeyToSlug[modelKey as keyof typeof baModelKeyToSlug] ?? modelKey;\n\n  switch (modelKey) {\n    case 'user':\n      return pluginOptions.users?.slug ?? baseSlugs.users;\n    case 'account':\n      return pluginOptions.accounts?.slug ?? baseSlugs.accounts;\n    case 'session':\n      return pluginOptions.sessions?.slug ?? baseSlugs.sessions;\n    case 'verification':\n      return pluginOptions.verifications?.slug ?? baseSlugs.verifications;\n    case 'adminInvitation':\n      return pluginOptions.adminInvitations?.slug ?? baseSlugs.adminInvitations;\n    default:\n      return baseSlug;\n  }\n}\n"],"names":["baModelKeyToSlug","baseSlugs","getDefaultCollectionSlug","pluginOptions","modelKey","baseSlug","users","slug","accounts","sessions","verifications","adminInvitations"],"mappings":"AAAA,SAASA,gBAAgB,EAAEC,SAAS,QAAQ,eAAe;AAG3D,OAAO,SAASC,yBAAyB,EACvCC,aAAa,EACbC,QAAQ,EAIT;IACC,MAAMC,WAAWL,gBAAgB,CAACI,SAA0C,IAAIA;IAEhF,OAAQA;QACN,KAAK;YACH,OAAOD,cAAcG,KAAK,EAAEC,QAAQN,UAAUK,KAAK;QACrD,KAAK;YACH,OAAOH,cAAcK,QAAQ,EAAED,QAAQN,UAAUO,QAAQ;QAC3D,KAAK;YACH,OAAOL,cAAcM,QAAQ,EAAEF,QAAQN,UAAUQ,QAAQ;QAC3D,KAAK;YACH,OAAON,cAAcO,aAAa,EAAEH,QAAQN,UAAUS,aAAa;QACrE,KAAK;YACH,OAAOP,cAAcQ,gBAAgB,EAAEJ,QAAQN,UAAUU,gBAAgB;QAC3E;YACE,OAAON;IACX;AACF"}

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

@@ -0,0 +1,15 @@
+import type { BetterAuthFullSchema, ModelKey } from '@/better-auth/generated-types';
+import { type Collection, type CollectionConfig } from 'payload';
+export declare function getCollectionByModelKey(collections: Record<string, Collection>, modelKey: ModelKey): CollectionConfig;
+/**
+ * Retrieves the field name from a collection based on the field key
+ *
+ * This function searches through the fields of a collection to find a field
+ * that has a matching custom property betterAuthFieldKey.
+ *
+ * @param collection - The collection configuration to search through
+ * @param model - The model key of the collection (This is really just for type hinting)
+ * @param fieldKey - The key of the field to search for
+ * @returns The name of the field if found, otherwise the field key itself
+ */
+export declare function getCollectionFieldNameByFieldKey<M extends ModelKey>(collection: CollectionConfig, _model: M, fieldKey: Extract<keyof BetterAuthFullSchema[M], string>): string;

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

@@ -0,0 +1,29 @@
+import { flattenAllFields } from "payload";
+export function getCollectionByModelKey(collections, modelKey) {
+    const collection = Object.values(collections).find((collectionItem)=>{
+        const customConfig = collectionItem.config?.custom;
+        return customConfig?.betterAuthModelKey === modelKey;
+    });
+    if (!collection) {
+        throw new Error(`Collection with key ${modelKey} not found`);
+    }
+    return collection.config;
+}
+/**
+ * Retrieves the field name from a collection based on the field key
+ *
+ * This function searches through the fields of a collection to find a field
+ * that has a matching custom property betterAuthFieldKey.
+ *
+ * @param collection - The collection configuration to search through
+ * @param model - The model key of the collection (This is really just for type hinting)
+ * @param fieldKey - The key of the field to search for
+ * @returns The name of the field if found, otherwise the field key itself
+ */ export function getCollectionFieldNameByFieldKey(collection, _model, fieldKey) {
+    const fields = flattenAllFields({
+        fields: collection.fields
+    });
+    return fields.find((field)=>field.custom?.betterAuthFieldKey === fieldKey)?.name ?? fieldKey;
+}
+
+//# sourceMappingURL=get-collection.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/better-auth/plugin/helpers/get-collection.ts"],"sourcesContent":["import type { BetterAuthFullSchema, ModelKey } from '@/better-auth/generated-types';\nimport { type Collection, type CollectionConfig, flattenAllFields } from 'payload';\n\nexport function getCollectionByModelKey(\n  collections: Record<string, Collection>,\n  modelKey: ModelKey\n): CollectionConfig {\n  const collection = Object.values(collections).find(collectionItem => {\n    const customConfig = collectionItem.config?.custom as\n      | { betterAuthModelKey?: string }\n      | undefined;\n    return customConfig?.betterAuthModelKey === modelKey;\n  });\n\n  if (!collection) {\n    throw new Error(`Collection with key ${modelKey} not found`);\n  }\n\n  return collection.config;\n}\n\n/**\n * Retrieves the field name from a collection based on the field key\n *\n * This function searches through the fields of a collection to find a field\n * that has a matching custom property betterAuthFieldKey.\n *\n * @param collection - The collection configuration to search through\n * @param model - The model key of the collection (This is really just for type hinting)\n * @param fieldKey - The key of the field to search for\n * @returns The name of the field if found, otherwise the field key itself\n */\nexport function getCollectionFieldNameByFieldKey<M extends ModelKey>(\n  collection: CollectionConfig,\n  _model: M,\n  fieldKey: Extract<keyof BetterAuthFullSchema[M], string>\n): string {\n  const fields = flattenAllFields({ fields: collection.fields });\n  return fields.find(field => field.custom?.betterAuthFieldKey === fieldKey)?.name ?? fieldKey;\n}\n"],"names":["flattenAllFields","getCollectionByModelKey","collections","modelKey","collection","Object","values","find","collectionItem","customConfig","config","custom","betterAuthModelKey","Error","getCollectionFieldNameByFieldKey","_model","fieldKey","fields","field","betterAuthFieldKey","name"],"mappings":"AACA,SAAiDA,gBAAgB,QAAQ,UAAU;AAEnF,OAAO,SAASC,wBACdC,WAAuC,EACvCC,QAAkB;IAElB,MAAMC,aAAaC,OAAOC,MAAM,CAACJ,aAAaK,IAAI,CAACC,CAAAA;QACjD,MAAMC,eAAeD,eAAeE,MAAM,EAAEC;QAG5C,OAAOF,cAAcG,uBAAuBT;IAC9C;IAEA,IAAI,CAACC,YAAY;QACf,MAAM,IAAIS,MAAM,CAAC,oBAAoB,EAAEV,SAAS,UAAU,CAAC;IAC7D;IAEA,OAAOC,WAAWM,MAAM;AAC1B;AAEA;;;;;;;;;;CAUC,GACD,OAAO,SAASI,iCACdV,UAA4B,EAC5BW,MAAS,EACTC,QAAwD;IAExD,MAAMC,SAASjB,iBAAiB;QAAEiB,QAAQb,WAAWa,MAAM;IAAC;IAC5D,OAAOA,OAAOV,IAAI,CAACW,CAAAA,QAASA,MAAMP,MAAM,EAAEQ,uBAAuBH,WAAWI,QAAQJ;AACtF"}

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

@@ -0,0 +1,2 @@
+import type { BetterAuthOptions } from 'better-auth';
+export declare function getIp(headers: Headers, options: BetterAuthOptions): string | null;

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

@@ -0,0 +1,31 @@
+export function getIp(headers, options) {
+    if (options.advanced?.ipAddress?.disableIpTracking) {
+        return null;
+    }
+    const testIP = '127.0.0.1';
+    if ((process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development') ?? false) {
+        return testIP;
+    }
+    const ipHeaders = options.advanced?.ipAddress?.ipAddressHeaders;
+    const keys = ipHeaders ?? [
+        'x-client-ip',
+        'x-forwarded-for',
+        'cf-connecting-ip',
+        'fastly-client-ip',
+        'x-real-ip',
+        'x-cluster-client-ip',
+        'x-forwarded',
+        'forwarded-for',
+        'forwarded'
+    ];
+    for (const key of keys){
+        const value = headers.get(key);
+        if (typeof value === 'string') {
+            const ip = value.split(',')[0]?.trim();
+            if (ip) return ip;
+        }
+    }
+    return null;
+}
+
+//# sourceMappingURL=get-ip.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/better-auth/plugin/helpers/get-ip.ts"],"sourcesContent":["import type { BetterAuthOptions } from 'better-auth';\n\nexport function getIp(headers: Headers, options: BetterAuthOptions): string | null {\n  if (options.advanced?.ipAddress?.disableIpTracking) {\n    return null;\n  }\n  const testIP = '127.0.0.1';\n  if ((process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development') ?? false) {\n    return testIP;\n  }\n  const ipHeaders = options.advanced?.ipAddress?.ipAddressHeaders;\n  const keys = ipHeaders ?? [\n    'x-client-ip',\n    'x-forwarded-for',\n    'cf-connecting-ip',\n    'fastly-client-ip',\n    'x-real-ip',\n    'x-cluster-client-ip',\n    'x-forwarded',\n    'forwarded-for',\n    'forwarded',\n  ];\n  for (const key of keys) {\n    const value = headers.get(key);\n    if (typeof value === 'string') {\n      const ip = value.split(',')[0]?.trim();\n      if (ip) return ip;\n    }\n  }\n  return null;\n}\n"],"names":["getIp","headers","options","advanced","ipAddress","disableIpTracking","testIP","process","env","NODE_ENV","ipHeaders","ipAddressHeaders","keys","key","value","get","ip","split","trim"],"mappings":"AAEA,OAAO,SAASA,MAAMC,OAAgB,EAAEC,OAA0B;IAChE,IAAIA,QAAQC,QAAQ,EAAEC,WAAWC,mBAAmB;QAClD,OAAO;IACT;IACA,MAAMC,SAAS;IACf,IAAI,AAACC,CAAAA,QAAQC,GAAG,CAACC,QAAQ,KAAK,UAAUF,QAAQC,GAAG,CAACC,QAAQ,KAAK,aAAY,KAAM,OAAO;QACxF,OAAOH;IACT;IACA,MAAMI,YAAYR,QAAQC,QAAQ,EAAEC,WAAWO;IAC/C,MAAMC,OAAOF,aAAa;QACxB;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;KACD;IACD,KAAK,MAAMG,OAAOD,KAAM;QACtB,MAAME,QAAQb,QAAQc,GAAG,CAACF;QAC1B,IAAI,OAAOC,UAAU,UAAU;YAC7B,MAAME,KAAKF,MAAMG,KAAK,CAAC,IAAI,CAAC,EAAE,EAAEC;YAChC,IAAIF,IAAI,OAAOA;QACjB;IACF;IACA,OAAO;AACT"}

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

@@ -0,0 +1,2 @@
+import type { CookiePrefixOptions } from 'better-auth';
+export declare function getSignedCookie(cookies: string, key: string, secret: string, prefix?: CookiePrefixOptions): Promise<string | false>;

package/dist/better-auth/plugin/helpers/get-signed-cookie.js

@@ -0,0 +1,65 @@
+import { getWebcryptoSubtle } from "@better-auth/utils";
+import { parseCookies } from "better-auth/cookies";
+const algorithm = {
+    name: 'HMAC',
+    hash: 'SHA-256'
+};
+const getCookieKey = (key, prefix)=>{
+    let finalKey = key;
+    if (prefix) {
+        if (prefix === 'secure') {
+            finalKey = `__Secure-${key}`;
+        } else if (prefix === 'host') {
+            finalKey = `__Host-${key}`;
+        } else {
+            return undefined;
+        }
+    }
+    return finalKey;
+};
+const getCryptoKey = async (secret)=>{
+    const secretBuf = typeof secret === 'string' ? new TextEncoder().encode(secret) : secret;
+    return await getWebcryptoSubtle().importKey('raw', secretBuf, algorithm, false, [
+        'sign',
+        'verify'
+    ]);
+};
+const verifySignature = async (base64Signature, value, secret)=>{
+    try {
+        const signatureBinStr = atob(base64Signature);
+        const signature = new Uint8Array(signatureBinStr.length);
+        for(let i = 0, len = signatureBinStr.length; i < len; i++){
+            signature[i] = signatureBinStr.charCodeAt(i);
+        }
+        return await getWebcryptoSubtle().verify(algorithm, secret, signature, new TextEncoder().encode(value));
+    } catch (_e) {
+        // Signature verification failed - invalid signature format or crypto error
+        // Error details are intentionally not logged to avoid exposing sensitive cryptographic information
+        return false;
+    }
+};
+export async function getSignedCookie(cookies, key, secret, prefix) {
+    const parsedCookies = cookies ? parseCookies(cookies) : undefined;
+    const finalKey = getCookieKey(key, prefix);
+    if (!finalKey) {
+        return null;
+    }
+    const value = parsedCookies?.get(finalKey);
+    if (!value) {
+        return null;
+    }
+    const signatureStartPos = value.lastIndexOf('.');
+    if (signatureStartPos < 1) {
+        return null;
+    }
+    const signedValue = value.substring(0, signatureStartPos);
+    const signature = value.substring(signatureStartPos + 1);
+    if (signature.length !== 44 || !signature.endsWith('=')) {
+        return null;
+    }
+    const secretKey = await getCryptoKey(secret);
+    const isVerified = await verifySignature(signature, signedValue, secretKey);
+    return isVerified ? signedValue : false;
+}
+
+//# sourceMappingURL=get-signed-cookie.js.map

package/dist/better-auth/plugin/helpers/get-signed-cookie.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/better-auth/plugin/helpers/get-signed-cookie.ts"],"sourcesContent":["import { getWebcryptoSubtle } from '@better-auth/utils';\nimport type { CookiePrefixOptions } from 'better-auth';\nimport { parseCookies } from 'better-auth/cookies';\n\nconst algorithm = { name: 'HMAC', hash: 'SHA-256' };\n\nconst getCookieKey = (key: string, prefix?: CookiePrefixOptions) => {\n  let finalKey = key;\n  if (prefix) {\n    if (prefix === 'secure') {\n      finalKey = `__Secure-${key}`;\n    } else if (prefix === 'host') {\n      finalKey = `__Host-${key}`;\n    } else {\n      return undefined;\n    }\n  }\n  return finalKey;\n};\n\nconst getCryptoKey = async (secret: string | BufferSource) => {\n  const secretBuf = typeof secret === 'string' ? new TextEncoder().encode(secret) : secret;\n  return await getWebcryptoSubtle().importKey('raw', secretBuf, algorithm, false, [\n    'sign',\n    'verify',\n  ]);\n};\n\nconst verifySignature = async (\n  base64Signature: string,\n  value: string,\n  secret: CryptoKey\n): Promise<boolean> => {\n  try {\n    const signatureBinStr = atob(base64Signature);\n    const signature = new Uint8Array(signatureBinStr.length);\n    for (let i = 0, len = signatureBinStr.length; i < len; i++) {\n      signature[i] = signatureBinStr.charCodeAt(i);\n    }\n    return await getWebcryptoSubtle().verify(\n      algorithm,\n      secret,\n      signature,\n      new TextEncoder().encode(value)\n    );\n  } catch (_e) {\n    // Signature verification failed - invalid signature format or crypto error\n    // Error details are intentionally not logged to avoid exposing sensitive cryptographic information\n    return false;\n  }\n};\n\nexport async function getSignedCookie(\n  cookies: string,\n  key: string,\n  secret: string,\n  prefix?: CookiePrefixOptions\n) {\n  const parsedCookies = cookies ? parseCookies(cookies) : undefined;\n\n  const finalKey = getCookieKey(key, prefix);\n  if (!finalKey) {\n    return null;\n  }\n  const value = parsedCookies?.get(finalKey);\n  if (!value) {\n    return null;\n  }\n  const signatureStartPos = value.lastIndexOf('.');\n  if (signatureStartPos < 1) {\n    return null;\n  }\n  const signedValue = value.substring(0, signatureStartPos);\n  const signature = value.substring(signatureStartPos + 1);\n  if (signature.length !== 44 || !signature.endsWith('=')) {\n    return null;\n  }\n  const secretKey = await getCryptoKey(secret);\n  const isVerified = await verifySignature(signature, signedValue, secretKey);\n  return isVerified ? signedValue : false;\n}\n"],"names":["getWebcryptoSubtle","parseCookies","algorithm","name","hash","getCookieKey","key","prefix","finalKey","undefined","getCryptoKey","secret","secretBuf","TextEncoder","encode","importKey","verifySignature","base64Signature","value","signatureBinStr","atob","signature","Uint8Array","length","i","len","charCodeAt","verify","_e","getSignedCookie","cookies","parsedCookies","get","signatureStartPos","lastIndexOf","signedValue","substring","endsWith","secretKey","isVerified"],"mappings":"AAAA,SAASA,kBAAkB,QAAQ,qBAAqB;AAExD,SAASC,YAAY,QAAQ,sBAAsB;AAEnD,MAAMC,YAAY;IAAEC,MAAM;IAAQC,MAAM;AAAU;AAElD,MAAMC,eAAe,CAACC,KAAaC;IACjC,IAAIC,WAAWF;IACf,IAAIC,QAAQ;QACV,IAAIA,WAAW,UAAU;YACvBC,WAAW,CAAC,SAAS,EAAEF,KAAK;QAC9B,OAAO,IAAIC,WAAW,QAAQ;YAC5BC,WAAW,CAAC,OAAO,EAAEF,KAAK;QAC5B,OAAO;YACL,OAAOG;QACT;IACF;IACA,OAAOD;AACT;AAEA,MAAME,eAAe,OAAOC;IAC1B,MAAMC,YAAY,OAAOD,WAAW,WAAW,IAAIE,cAAcC,MAAM,CAACH,UAAUA;IAClF,OAAO,MAAMX,qBAAqBe,SAAS,CAAC,OAAOH,WAAWV,WAAW,OAAO;QAC9E;QACA;KACD;AACH;AAEA,MAAMc,kBAAkB,OACtBC,iBACAC,OACAP;IAEA,IAAI;QACF,MAAMQ,kBAAkBC,KAAKH;QAC7B,MAAMI,YAAY,IAAIC,WAAWH,gBAAgBI,MAAM;QACvD,IAAK,IAAIC,IAAI,GAAGC,MAAMN,gBAAgBI,MAAM,EAAEC,IAAIC,KAAKD,IAAK;YAC1DH,SAAS,CAACG,EAAE,GAAGL,gBAAgBO,UAAU,CAACF;QAC5C;QACA,OAAO,MAAMxB,qBAAqB2B,MAAM,CACtCzB,WACAS,QACAU,WACA,IAAIR,cAAcC,MAAM,CAACI;IAE7B,EAAE,OAAOU,IAAI;QACX,2EAA2E;QAC3E,mGAAmG;QACnG,OAAO;IACT;AACF;AAEA,OAAO,eAAeC,gBACpBC,OAAe,EACfxB,GAAW,EACXK,MAAc,EACdJ,MAA4B;IAE5B,MAAMwB,gBAAgBD,UAAU7B,aAAa6B,WAAWrB;IAExD,MAAMD,WAAWH,aAAaC,KAAKC;IACnC,IAAI,CAACC,UAAU;QACb,OAAO;IACT;IACA,MAAMU,QAAQa,eAAeC,IAAIxB;IACjC,IAAI,CAACU,OAAO;QACV,OAAO;IACT;IACA,MAAMe,oBAAoBf,MAAMgB,WAAW,CAAC;IAC5C,IAAID,oBAAoB,GAAG;QACzB,OAAO;IACT;IACA,MAAME,cAAcjB,MAAMkB,SAAS,CAAC,GAAGH;IACvC,MAAMZ,YAAYH,MAAMkB,SAAS,CAACH,oBAAoB;IACtD,IAAIZ,UAAUE,MAAM,KAAK,MAAM,CAACF,UAAUgB,QAAQ,CAAC,MAAM;QACvD,OAAO;IACT;IACA,MAAMC,YAAY,MAAM5B,aAAaC;IACrC,MAAM4B,aAAa,MAAMvB,gBAAgBK,WAAWc,aAAaG;IACjE,OAAOC,aAAaJ,cAAc;AACpC"}

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

@@ -0,0 +1 @@
+export { generateVerifyEmailUrl } from './generate-verify-email-url';

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

@@ -0,0 +1,3 @@
+export { generateVerifyEmailUrl } from "./generate-verify-email-url";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/better-auth/plugin/helpers/index.ts"],"sourcesContent":["export { generateVerifyEmailUrl } from './generate-verify-email-url';\n"],"names":["generateVerifyEmailUrl"],"mappings":"AAAA,SAASA,sBAAsB,QAAQ,8BAA8B"}

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

@@ -0,0 +1,59 @@
+import type { Session, User } from 'better-auth';
+import type { CollectionConfig } from 'payload';
+export declare function prepareUser({ user, userCollection, }: {
+    user: User & Record<string, any>;
+    userCollection: CollectionConfig;
+}): Promise<{
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    emailVerified: boolean;
+    name: string;
+    email?: string;
+    image?: string;
+} & Record<string, any>>;
+export declare function prepareSession({ session, sessionCollection, }: {
+    session: Session & Record<string, any>;
+    sessionCollection: CollectionConfig;
+}): Promise<{
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string;
+    expiresAt: Date;
+    token: string;
+    ipAddress?: string;
+    userAgent?: string;
+} & Record<string, any>>;
+/**
+ * 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, sessionsCollection, usersCollection, }: {
+    sessionData: {
+        session: Session & Record<string, any>;
+        user: User & Record<string, any>;
+    };
+    usersCollection: CollectionConfig;
+    sessionsCollection: CollectionConfig;
+}): Promise<{
+    session: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string;
+        userAgent?: string;
+    } & Record<string, any>;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        emailVerified: boolean;
+        name: string;
+        email?: string;
+        image?: string;
+    } & Record<string, any>;
+}>;

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

@@ -0,0 +1,49 @@
+import { getFieldsToSign } from "payload";
+export async function prepareUser({ user, userCollection }) {
+    const newUser = getFieldsToSign({
+        collectionConfig: userCollection,
+        email: user.email,
+        user: {
+            ...user,
+            collection: userCollection.slug
+        }
+    });
+    return newUser;
+}
+export async function prepareSession({ session, sessionCollection }) {
+    const filteredSession = getFieldsToSign({
+        collectionConfig: sessionCollection,
+        email: '',
+        user: {
+            ...session,
+            collection: sessionCollection.slug
+        }
+    });
+    filteredSession.email = undefined;
+    filteredSession.collection = undefined;
+    Object.assign(filteredSession, {
+        userId: session.userId
+    });
+    return filteredSession;
+}
+/**
+ * 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, sessionsCollection, usersCollection }) {
+    if (!sessionData || !sessionData.user) return null;
+    const newUser = await prepareUser({
+        user: sessionData.user,
+        userCollection: usersCollection
+    });
+    const newSession = await prepareSession({
+        session: sessionData.session,
+        sessionCollection: sessionsCollection
+    });
+    const newSessionData = {
+        session: newSession,
+        user: newUser
+    };
+    return newSessionData;
+}
+
+//# sourceMappingURL=prepare-session-data.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/better-auth/plugin/helpers/prepare-session-data.ts"],"sourcesContent":["import { getFieldsToSign } from 'payload';\n\nimport type { Session, User } from 'better-auth';\nimport type { CollectionConfig } from 'payload';\n\nexport async function prepareUser({\n  user,\n  userCollection,\n}: {\n  user: User & Record<string, any>;\n  userCollection: CollectionConfig;\n}) {\n  const newUser = getFieldsToSign({\n    collectionConfig: userCollection,\n    email: user.email,\n    user: {\n      ...user,\n      collection: userCollection.slug as 'users',\n    } as any,\n  });\n\n  return newUser as User & Record<string, any>;\n}\n\nexport async function prepareSession({\n  session,\n  sessionCollection,\n}: {\n  session: Session & Record<string, any>;\n  sessionCollection: CollectionConfig;\n}) {\n  const filteredSession = getFieldsToSign({\n    collectionConfig: sessionCollection,\n    email: '',\n    user: {\n      ...session,\n      collection: sessionCollection.slug as 'sessions',\n    } as any,\n  });\n\n  filteredSession.email = undefined;\n  filteredSession.collection = undefined;\n  Object.assign(filteredSession, {\n    userId: session.userId,\n  });\n\n  return filteredSession as Session & Record<string, any>;\n}\n\n/**\n * Prepares session data for cookie cache by filtering user and session objects\n * based on the payload configuration's 'saveToJwt' property\n */\nexport async function prepareSessionData({\n  sessionData,\n  sessionsCollection,\n  usersCollection,\n}: {\n  sessionData: {\n    session: Session & Record<string, any>;\n    user: User & Record<string, any>;\n  };\n  usersCollection: CollectionConfig;\n  sessionsCollection: CollectionConfig;\n}) {\n  if (!sessionData || !sessionData.user) return null;\n\n  const newUser = await prepareUser({ user: sessionData.user, userCollection: usersCollection });\n  const newSession = await prepareSession({\n    session: sessionData.session,\n    sessionCollection: sessionsCollection,\n  });\n\n  const newSessionData = {\n    session: newSession,\n    user: newUser,\n  };\n\n  return newSessionData;\n}\n"],"names":["getFieldsToSign","prepareUser","user","userCollection","newUser","collectionConfig","email","collection","slug","prepareSession","session","sessionCollection","filteredSession","undefined","Object","assign","userId","prepareSessionData","sessionData","sessionsCollection","usersCollection","newSession","newSessionData"],"mappings":"AAAA,SAASA,eAAe,QAAQ,UAAU;AAK1C,OAAO,eAAeC,YAAY,EAChCC,IAAI,EACJC,cAAc,EAIf;IACC,MAAMC,UAAUJ,gBAAgB;QAC9BK,kBAAkBF;QAClBG,OAAOJ,KAAKI,KAAK;QACjBJ,MAAM;YACJ,GAAGA,IAAI;YACPK,YAAYJ,eAAeK,IAAI;QACjC;IACF;IAEA,OAAOJ;AACT;AAEA,OAAO,eAAeK,eAAe,EACnCC,OAAO,EACPC,iBAAiB,EAIlB;IACC,MAAMC,kBAAkBZ,gBAAgB;QACtCK,kBAAkBM;QAClBL,OAAO;QACPJ,MAAM;YACJ,GAAGQ,OAAO;YACVH,YAAYI,kBAAkBH,IAAI;QACpC;IACF;IAEAI,gBAAgBN,KAAK,GAAGO;IACxBD,gBAAgBL,UAAU,GAAGM;IAC7BC,OAAOC,MAAM,CAACH,iBAAiB;QAC7BI,QAAQN,QAAQM,MAAM;IACxB;IAEA,OAAOJ;AACT;AAEA;;;CAGC,GACD,OAAO,eAAeK,mBAAmB,EACvCC,WAAW,EACXC,kBAAkB,EAClBC,eAAe,EAQhB;IACC,IAAI,CAACF,eAAe,CAACA,YAAYhB,IAAI,EAAE,OAAO;IAE9C,MAAME,UAAU,MAAMH,YAAY;QAAEC,MAAMgB,YAAYhB,IAAI;QAAEC,gBAAgBiB;IAAgB;IAC5F,MAAMC,aAAa,MAAMZ,eAAe;QACtCC,SAASQ,YAAYR,OAAO;QAC5BC,mBAAmBQ;IACrB;IAEA,MAAMG,iBAAiB;QACrBZ,SAASW;QACTnB,MAAME;IACR;IAEA,OAAOkB;AACT"}

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/better-auth/plugin/helpers/sync-resolved-schema-with-collection-map.ts"],"sourcesContent":["import type { CollectionConfig } from 'payload';\nimport type { ModelKey } from '../../generated-types';\nimport type { BetterAuthSchemas, FieldWithIds } from '../types';\n\ntype BetterAuthCollectionCustom = {\n  betterAuthModelKey?: string;\n  betterAuthFieldKey?: string;\n};\n\n/**\n * Syncs a BetterAuth `ResolvedSchema` object with the *actual* collection\n * definitions created by this plugin.\n *\n * This must run **after** the first call to `buildCollections`, because only\n * then do we know the user-overridden slugs / field names.  The algorithm is\n * kept deliberately simple:\n *\n *  1. Build a `modelKey → newSlug` map from each collection's\n *     `custom.betterAuthModelKey` property.\n *  2. Update `schema.modelName` for all affected tables.\n *  3. Rewrite `references.model` in *every* table field according to the new\n *     slugs.  We do this in a dedicated pass so referencing tables no longer\n *     depend on the original slugs.\n *  4. Finally, iterate collections once more to apply any *field* renames via\n *     the `custom.betterAuthFieldKey` property.\n */\nexport function syncResolvedSchemaWithCollectionMap(\n  resolvedSchemas: BetterAuthSchemas,\n  collectionMap: Record<string, CollectionConfig>\n): BetterAuthSchemas {\n  const collections = Object.values(collectionMap);\n\n  // Helper to update references across the whole schema\n  const updateReferences = (oldSlug: string, newSlug: string): void => {\n    for (const schema of Object.values(resolvedSchemas)) {\n      for (const fieldAttr of Object.values(schema.fields)) {\n        const ref = fieldAttr.references;\n        if (ref?.model === oldSlug) {\n          ref.model = newSlug;\n        }\n      }\n    }\n  };\n\n  for (const [modelKey, schema] of Object.entries(resolvedSchemas) as [\n    ModelKey,\n    (typeof resolvedSchemas)[ModelKey],\n  ][]) {\n    const collection = collections.find(collectionItem => {\n      const custom = collectionItem.custom as BetterAuthCollectionCustom | undefined;\n      return custom?.betterAuthModelKey === modelKey;\n    });\n    if (!collection) {\n      // Configuration-time error - logger not available during schema sync\n\n      console.error(`Collection not found for model key: ${modelKey}`);\n      continue;\n    }\n\n    // ───── Sync slug ─────────────────────────────────────────────────────────\n    const oldSlug = schema.modelName;\n    const newSlug = collection.slug;\n\n    if (oldSlug !== newSlug) {\n      // First, rewrite *all* references that still point to the old slug\n      updateReferences(oldSlug, newSlug);\n\n      // Now store the new slug on the schema itself\n      schema.modelName = newSlug;\n    }\n\n    // ───── Sync field names ───────────────────────────────────────────────────\n    const collectionFields: FieldWithIds[] = Array.isArray(collection.fields)\n      ? (collection.fields as FieldWithIds[])\n      : [];\n\n    for (const [fieldKey, schemaField] of Object.entries(schema.fields)) {\n      const matchingField = collectionFields.find(\n        field => field.custom?.betterAuthFieldKey === fieldKey\n      );\n\n      if (!matchingField) {\n        // Configuration-time error - logger not available during schema sync\n\n        console.error(`Field not found for key \"${fieldKey}\" in collection \"${collection.slug}\"`);\n        continue;\n      }\n\n      const newName = matchingField.name;\n      if (newName && schemaField.fieldName !== newName) {\n        schemaField.fieldName = newName;\n      }\n    }\n  }\n\n  return resolvedSchemas;\n}\n"],"names":["syncResolvedSchemaWithCollectionMap","resolvedSchemas","collectionMap","collections","Object","values","updateReferences","oldSlug","newSlug","schema","fieldAttr","fields","ref","references","model","modelKey","entries","collection","find","collectionItem","custom","betterAuthModelKey","console","error","modelName","slug","collectionFields","Array","isArray","fieldKey","schemaField","matchingField","field","betterAuthFieldKey","newName","name","fieldName"],"mappings":"AASA;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,SAASA,oCACdC,eAAkC,EAClCC,aAA+C;IAE/C,MAAMC,cAAcC,OAAOC,MAAM,CAACH;IAElC,sDAAsD;IACtD,MAAMI,mBAAmB,CAACC,SAAiBC;QACzC,KAAK,MAAMC,UAAUL,OAAOC,MAAM,CAACJ,iBAAkB;YACnD,KAAK,MAAMS,aAAaN,OAAOC,MAAM,CAACI,OAAOE,MAAM,EAAG;gBACpD,MAAMC,MAAMF,UAAUG,UAAU;gBAChC,IAAID,KAAKE,UAAUP,SAAS;oBAC1BK,IAAIE,KAAK,GAAGN;gBACd;YACF;QACF;IACF;IAEA,KAAK,MAAM,CAACO,UAAUN,OAAO,IAAIL,OAAOY,OAAO,CAACf,iBAG3C;QACH,MAAMgB,aAAad,YAAYe,IAAI,CAACC,CAAAA;YAClC,MAAMC,SAASD,eAAeC,MAAM;YACpC,OAAOA,QAAQC,uBAAuBN;QACxC;QACA,IAAI,CAACE,YAAY;YACf,qEAAqE;YAErEK,QAAQC,KAAK,CAAC,CAAC,oCAAoC,EAAER,UAAU;YAC/D;QACF;QAEA,4EAA4E;QAC5E,MAAMR,UAAUE,OAAOe,SAAS;QAChC,MAAMhB,UAAUS,WAAWQ,IAAI;QAE/B,IAAIlB,YAAYC,SAAS;YACvB,mEAAmE;YACnEF,iBAAiBC,SAASC;YAE1B,8CAA8C;YAC9CC,OAAOe,SAAS,GAAGhB;QACrB;QAEA,6EAA6E;QAC7E,MAAMkB,mBAAmCC,MAAMC,OAAO,CAACX,WAAWN,MAAM,IACnEM,WAAWN,MAAM,GAClB,EAAE;QAEN,KAAK,MAAM,CAACkB,UAAUC,YAAY,IAAI1B,OAAOY,OAAO,CAACP,OAAOE,MAAM,EAAG;YACnE,MAAMoB,gBAAgBL,iBAAiBR,IAAI,CACzCc,CAAAA,QAASA,MAAMZ,MAAM,EAAEa,uBAAuBJ;YAGhD,IAAI,CAACE,eAAe;gBAClB,qEAAqE;gBAErET,QAAQC,KAAK,CAAC,CAAC,yBAAyB,EAAEM,SAAS,iBAAiB,EAAEZ,WAAWQ,IAAI,CAAC,CAAC,CAAC;gBACxF;YACF;YAEA,MAAMS,UAAUH,cAAcI,IAAI;YAClC,IAAID,WAAWJ,YAAYM,SAAS,KAAKF,SAAS;gBAChDJ,YAAYM,SAAS,GAAGF;YAC1B;QACF;IACF;IAEA,OAAOjC;AACT"}

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

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