@luochuanyuewu/payload-auth 1.8.0

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

@@ -0,0 +1,28 @@
+import { type Collection, type CollectionConfig } from "payload";
+import type { BetterAuthFullSchema, ModelKey } from "@/better-auth/generated-types";
+export declare function getCollectionByModelKey(collections: Record<string, Collection>, modelKey: ModelKey | string): 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;
+export declare function getCollectionFieldNameByFieldKeyUntyped(collection: CollectionConfig, fieldKey: string): string;
+/**
+ * Retrieves the field key from a collection based on the collection field name
+ *
+ * This function searches through the fields of a collection to find a field
+ * that has a matching name.
+ *
+ * @param collection - The collection configuration to search through
+ * @param fieldName - The name of the field to search for
+ * @returns The key of the field if found, otherwise the field name itself
+ */
+export declare function getFieldKeyByCollectionFieldName(collection: CollectionConfig, fieldName: string): string;
+//# 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,EACL,KAAK,UAAU,EACf,KAAK,gBAAgB,EAEtB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EACV,oBAAoB,EACpB,QAAQ,EACT,MAAM,+BAA+B,CAAC;AAEvC,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EACvC,QAAQ,EAAE,QAAQ,GAAG,MAAM,GAC1B,gBAAgB,CAalB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gCAAgC,CAAC,CAAC,SAAS,QAAQ,EACjE,UAAU,EAAE,gBAAgB,EAC5B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,OAAO,CAAC,MAAM,oBAAoB,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,GACvD,MAAM,CAMR;AAED,wBAAgB,uCAAuC,CACrD,UAAU,EAAE,gBAAgB,EAC5B,QAAQ,EAAE,MAAM,GACf,MAAM,CAOR;AAED;;;;;;;;;GASG;AACH,wBAAgB,gCAAgC,CAC9C,UAAU,EAAE,gBAAgB,EAC5B,SAAS,EAAE,MAAM,GAChB,MAAM,CAMR"}

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

@@ -0,0 +1,49 @@
+import { flattenAllFields } from "payload";
+export function getCollectionByModelKey(collections, modelKey) {
+    const collection = Object.values(collections).find((c)=>{
+        return c.config?.custom?.betterAuthModelKey === modelKey || c.config?.slug === 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((f)=>f.custom?.betterAuthFieldKey === fieldKey)?.name ?? fieldKey;
+}
+export function getCollectionFieldNameByFieldKeyUntyped(collection, fieldKey) {
+    const fields = flattenAllFields({
+        fields: collection.fields
+    });
+    return fields.find((f)=>f.custom?.betterAuthFieldKey === fieldKey || f.name === fieldKey)?.name ?? fieldKey;
+}
+/**
+ * Retrieves the field key from a collection based on the collection field name
+ *
+ * This function searches through the fields of a collection to find a field
+ * that has a matching name.
+ *
+ * @param collection - The collection configuration to search through
+ * @param fieldName - The name of the field to search for
+ * @returns The key of the field if found, otherwise the field name itself
+ */ export function getFieldKeyByCollectionFieldName(collection, fieldName) {
+    const fields = flattenAllFields({
+        fields: collection.fields
+    });
+    return fields.find((f)=>f.name === fieldName)?.custom?.betterAuthFieldKey ?? fieldName;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,3 @@
+import type { BetterAuthOptions } from "better-auth";
+export declare function getIp(headers: Headers, options: BetterAuthOptions): string | null;
+//# sourceMappingURL=get-ip.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-ip.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/get-ip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,wBAAgB,KAAK,CACnB,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,iBAAiB,GACzB,MAAM,GAAG,IAAI,CAgCf"}

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=data:application/json;base64,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

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

@@ -0,0 +1,3 @@
+import { type CookiePrefixOptions } from "better-auth";
+export declare function getSignedCookie(cookies: string, key: string, secret: string, prefix?: CookiePrefixOptions): Promise<string | false | null>;
+//# sourceMappingURL=get-signed-cookie.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-signed-cookie.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/get-signed-cookie.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAqDvD,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,mBAAmB,kCAwB7B"}

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

@@ -0,0 +1,63 @@
+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) {
+        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=data:application/json;base64,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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC"}

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

@@ -0,0 +1,3 @@
+export { generateVerifyEmailUrl } from "./generate-verify-email-url";
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iZXR0ZXItYXV0aC9wbHVnaW4vaGVscGVycy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBnZW5lcmF0ZVZlcmlmeUVtYWlsVXJsIH0gZnJvbSBcIi4vZ2VuZXJhdGUtdmVyaWZ5LWVtYWlsLXVybFwiO1xuIl0sIm5hbWVzIjpbImdlbmVyYXRlVmVyaWZ5RW1haWxVcmwiXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLHNCQUFzQixRQUFRLDhCQUE4QiJ9

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

@@ -0,0 +1,60 @@
+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;
+    email: string;
+    emailVerified: boolean;
+    name: string;
+    image?: string | null | undefined;
+} & 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 | null | undefined;
+    userAgent?: string | null | undefined;
+} & 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, usersCollection, sessionsCollection }: {
+    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 | null | undefined;
+        userAgent?: string | null | undefined;
+    } & Record<string, any>;
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    } & Record<string, any>;
+} | null>;
+//# sourceMappingURL=prepare-session-data.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prepare-session-data.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/helpers/prepare-session-data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGhD,wBAAsB,WAAW,CAAC,EAChC,IAAI,EACJ,cAAc,EACf,EAAE;IACD,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACjC,cAAc,EAAE,gBAAgB,CAAC;CAClC;;;;;;;;yBAWA;AAED,wBAAsB,cAAc,CAAC,EACnC,OAAO,EACP,iBAAiB,EAClB,EAAE;IACD,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACvC,iBAAiB,EAAE,gBAAgB,CAAC;CACrC;;;;;;;;;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,CAAC;QACvC,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KAClC,CAAC;IACF,eAAe,EAAE,gBAAgB,CAAC;IAClC,kBAAkB,EAAE,gBAAgB,CAAC;CACtC;;;;;;;;;;;;;;;;;;;;UAkBA"}

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
+        }
+    });
+    delete filteredSession.email;
+    delete filteredSession.collection;
+    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, usersCollection, sessionsCollection }) {
+    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=data:application/json;base64,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

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

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

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

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

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

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

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

@@ -0,0 +1,8 @@
+import type { Config } from "payload";
+import type { PayloadAuthOptions } 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: PayloadAuthOptions): (config: Config) => Config;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/better-auth/plugin/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAmB,MAAM,SAAS,CAAC;AAQvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,yBAAyB,EAAE,MAAM,0CAA0C,CAAC;AACrF,cAAc,SAAS,CAAC;AAkDxB,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,kBAAkB,IACxD,QAAQ,MAAM,KAAG,MAAM,CAkEhC"}

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

@@ -0,0 +1,103 @@
+import { getDefaultBetterAuthSchema } from "./helpers/get-better-auth-schema";
+import { syncResolvedSchemaWithCollectionMap } from "./helpers/sync-resolved-schema-with-collection-map";
+import { applyDisabledDefaultAuthConfig } from "./lib/apply-disabled-default-auth-config";
+import { buildCollections } from "./lib/build-collections/index";
+import { initBetterAuth } from "./lib/init-better-auth";
+import { sanitizeBetterAuthOptions } from "./lib/sanitize-better-auth-options/index";
+import { setLoginMethods } from "./lib/set-login-methods";
+export * from "./helpers/index";
+export { getPayloadAuth } from "./lib/get-payload-auth";
+export { sanitizeBetterAuthOptions } from "./lib/sanitize-better-auth-options/index";
+export * from "./types";
+function buildBetterAuthData({ payloadConfig, pluginOptions }) {
+    pluginOptions = setLoginMethods({
+        pluginOptions
+    });
+    const defaultBetterAuthSchemas = getDefaultBetterAuthSchema(pluginOptions);
+    let collectionMap = buildCollections({
+        resolvedSchemas: defaultBetterAuthSchemas,
+        incomingCollections: payloadConfig.collections ?? [],
+        pluginOptions
+    });
+    const resolvedBetterAuthSchemas = syncResolvedSchemaWithCollectionMap(defaultBetterAuthSchemas, collectionMap);
+    // We need to build the collections a second time with the resolved schemas
+    // due to hooks, endpoints, useAsTitle, etc should rely on resolvedBetterAuthSchemas to get slugs
+    // if they are referencing to other collections then it self.
+    collectionMap = buildCollections({
+        resolvedSchemas: resolvedBetterAuthSchemas,
+        incomingCollections: payloadConfig.collections ?? [],
+        pluginOptions
+    });
+    const sanitizedBetterAuthOptions = sanitizeBetterAuthOptions({
+        config: payloadConfig,
+        pluginOptions,
+        resolvedSchemas: resolvedBetterAuthSchemas,
+        collections: Object.values(collectionMap)
+    });
+    pluginOptions.betterAuthOptions = sanitizedBetterAuthOptions;
+    return {
+        pluginOptions,
+        collectionMap,
+        resolvedBetterAuthSchemas,
+        sanitizedBetterAuthOptions
+    };
+}
+export function betterAuthPlugin(pluginOptions) {
+    return (config)=>{
+        if (pluginOptions.disabled) {
+            return config;
+        }
+        config.custom = {
+            ...config.custom,
+            hasBetterAuthPlugin: true
+        };
+        const { collectionMap, resolvedBetterAuthSchemas, sanitizedBetterAuthOptions } = buildBetterAuthData({
+            payloadConfig: config,
+            pluginOptions
+        });
+        // ---------------------- Finalize config -----------------
+        if (pluginOptions.disableDefaultPayloadAuth) {
+            applyDisabledDefaultAuthConfig({
+                config,
+                pluginOptions,
+                collectionMap,
+                resolvedBetterAuthSchemas
+            });
+        }
+        config.collections = config.collections ?? [];
+        config.collections = Object.values(collectionMap);
+        const incomingOnInit = config.onInit;
+        config.onInit = async (payload)=>{
+            try {
+                // Execute any existing onInit functions first
+                if (incomingOnInit) {
+                    await incomingOnInit(payload);
+                }
+                // Initialize and set the betterAuth instance
+                const auth = initBetterAuth({
+                    payload,
+                    idType: payload.db.defaultIDType,
+                    options: {
+                        ...sanitizedBetterAuthOptions,
+                        enableDebugLogs: pluginOptions.debug?.enableDebugLogs ?? false,
+                        plugins: [
+                            ...sanitizedBetterAuthOptions.plugins ?? []
+                        ]
+                    }
+                });
+                // Type-safe extension of payload with betterAuth
+                Object.defineProperty(payload, "betterAuth", {
+                    value: auth,
+                    writable: false,
+                    configurable: false
+                });
+            } catch (error) {
+                console.error("Failed to initialize BetterAuth:", error);
+                throw error;
+            }
+        };
+        return config;
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/better-auth/plugin/index.ts"],"sourcesContent":["import type { Config, SanitizedConfig } from \"payload\";\nimport { getDefaultBetterAuthSchema } from \"./helpers/get-better-auth-schema\";\nimport { syncResolvedSchemaWithCollectionMap } from \"./helpers/sync-resolved-schema-with-collection-map\";\nimport { applyDisabledDefaultAuthConfig } from \"./lib/apply-disabled-default-auth-config\";\nimport { buildCollections } from \"./lib/build-collections/index\";\nimport { initBetterAuth } from \"./lib/init-better-auth\";\nimport { sanitizeBetterAuthOptions } from \"./lib/sanitize-better-auth-options/index\";\nimport { setLoginMethods } from \"./lib/set-login-methods\";\nimport type { PayloadAuthOptions } from \"./types\";\n\nexport * from \"./helpers/index\";\nexport { getPayloadAuth } from \"./lib/get-payload-auth\";\nexport { sanitizeBetterAuthOptions } from \"./lib/sanitize-better-auth-options/index\";\nexport * from \"./types\";\n\nfunction buildBetterAuthData({\n  payloadConfig,\n  pluginOptions\n}: {\n  payloadConfig: SanitizedConfig;\n  pluginOptions: PayloadAuthOptions;\n}) {\n  pluginOptions = setLoginMethods({ pluginOptions });\n\n  const defaultBetterAuthSchemas = getDefaultBetterAuthSchema(pluginOptions);\n\n  let collectionMap = buildCollections({\n    resolvedSchemas: defaultBetterAuthSchemas,\n    incomingCollections: payloadConfig.collections ?? [],\n    pluginOptions\n  });\n\n  const resolvedBetterAuthSchemas = syncResolvedSchemaWithCollectionMap(\n    defaultBetterAuthSchemas,\n    collectionMap\n  );\n\n  // We need to build the collections a second time with the resolved schemas\n  // due to hooks, endpoints, useAsTitle, etc should rely on resolvedBetterAuthSchemas to get slugs\n  // if they are referencing to other collections then it self.\n  collectionMap = buildCollections({\n    resolvedSchemas: resolvedBetterAuthSchemas,\n    incomingCollections: payloadConfig.collections ?? [],\n    pluginOptions\n  });\n\n  const sanitizedBetterAuthOptions = sanitizeBetterAuthOptions({\n    config: payloadConfig,\n    pluginOptions,\n    resolvedSchemas: resolvedBetterAuthSchemas,\n    collections: Object.values(collectionMap)\n  });\n\n  pluginOptions.betterAuthOptions = sanitizedBetterAuthOptions;\n\n  return {\n    pluginOptions,\n    collectionMap,\n    resolvedBetterAuthSchemas,\n    sanitizedBetterAuthOptions\n  };\n}\n\nexport function betterAuthPlugin(pluginOptions: PayloadAuthOptions) {\n  return (config: Config): Config => {\n    if (pluginOptions.disabled) {\n      return config;\n    }\n\n    config.custom = {\n      ...config.custom,\n      hasBetterAuthPlugin: true\n    };\n\n    const {\n      collectionMap,\n      resolvedBetterAuthSchemas,\n      sanitizedBetterAuthOptions\n    } = buildBetterAuthData({\n      payloadConfig: config as SanitizedConfig,\n      pluginOptions\n    });\n\n    // ---------------------- Finalize config -----------------\n    if (pluginOptions.disableDefaultPayloadAuth) {\n      applyDisabledDefaultAuthConfig({\n        config,\n        pluginOptions,\n        collectionMap,\n        resolvedBetterAuthSchemas\n      });\n    }\n\n    config.collections = config.collections ?? [];\n    config.collections = Object.values(collectionMap);\n\n    const incomingOnInit = config.onInit;\n\n    config.onInit = async (payload) => {\n      try {\n        // Execute any existing onInit functions first\n        if (incomingOnInit) {\n          await incomingOnInit(payload);\n        }\n\n        // Initialize and set the betterAuth instance\n        const auth = initBetterAuth<typeof pluginOptions>({\n          payload,\n          idType: payload.db.defaultIDType,\n          options: {\n            ...sanitizedBetterAuthOptions,\n            enableDebugLogs: pluginOptions.debug?.enableDebugLogs ?? false,\n            plugins: [...(sanitizedBetterAuthOptions.plugins ?? [])]\n          }\n        });\n\n        // Type-safe extension of payload with betterAuth\n        Object.defineProperty(payload, \"betterAuth\", {\n          value: auth,\n          writable: false,\n          configurable: false\n        });\n      } catch (error) {\n        console.error(\"Failed to initialize BetterAuth:\", error);\n        throw error;\n      }\n    };\n\n    return config;\n  };\n}\n"],"names":["getDefaultBetterAuthSchema","syncResolvedSchemaWithCollectionMap","applyDisabledDefaultAuthConfig","buildCollections","initBetterAuth","sanitizeBetterAuthOptions","setLoginMethods","getPayloadAuth","buildBetterAuthData","payloadConfig","pluginOptions","defaultBetterAuthSchemas","collectionMap","resolvedSchemas","incomingCollections","collections","resolvedBetterAuthSchemas","sanitizedBetterAuthOptions","config","Object","values","betterAuthOptions","betterAuthPlugin","disabled","custom","hasBetterAuthPlugin","disableDefaultPayloadAuth","incomingOnInit","onInit","payload","auth","idType","db","defaultIDType","options","enableDebugLogs","debug","plugins","defineProperty","value","writable","configurable","error","console"],"mappings":"AACA,SAASA,0BAA0B,QAAQ,mCAAmC;AAC9E,SAASC,mCAAmC,QAAQ,qDAAqD;AACzG,SAASC,8BAA8B,QAAQ,2CAA2C;AAC1F,SAASC,gBAAgB,QAAQ,gCAAgC;AACjE,SAASC,cAAc,QAAQ,yBAAyB;AACxD,SAASC,yBAAyB,QAAQ,2CAA2C;AACrF,SAASC,eAAe,QAAQ,0BAA0B;AAG1D,cAAc,kBAAkB;AAChC,SAASC,cAAc,QAAQ,yBAAyB;AACxD,SAASF,yBAAyB,QAAQ,2CAA2C;AACrF,cAAc,UAAU;AAExB,SAASG,oBAAoB,EAC3BC,aAAa,EACbC,aAAa,EAId;IACCA,gBAAgBJ,gBAAgB;QAAEI;IAAc;IAEhD,MAAMC,2BAA2BX,2BAA2BU;IAE5D,IAAIE,gBAAgBT,iBAAiB;QACnCU,iBAAiBF;QACjBG,qBAAqBL,cAAcM,WAAW,IAAI,EAAE;QACpDL;IACF;IAEA,MAAMM,4BAA4Bf,oCAChCU,0BACAC;IAGF,2EAA2E;IAC3E,iGAAiG;IACjG,6DAA6D;IAC7DA,gBAAgBT,iBAAiB;QAC/BU,iBAAiBG;QACjBF,qBAAqBL,cAAcM,WAAW,IAAI,EAAE;QACpDL;IACF;IAEA,MAAMO,6BAA6BZ,0BAA0B;QAC3Da,QAAQT;QACRC;QACAG,iBAAiBG;QACjBD,aAAaI,OAAOC,MAAM,CAACR;IAC7B;IAEAF,cAAcW,iBAAiB,GAAGJ;IAElC,OAAO;QACLP;QACAE;QACAI;QACAC;IACF;AACF;AAEA,OAAO,SAASK,iBAAiBZ,aAAiC;IAChE,OAAO,CAACQ;QACN,IAAIR,cAAca,QAAQ,EAAE;YAC1B,OAAOL;QACT;QAEAA,OAAOM,MAAM,GAAG;YACd,GAAGN,OAAOM,MAAM;YAChBC,qBAAqB;QACvB;QAEA,MAAM,EACJb,aAAa,EACbI,yBAAyB,EACzBC,0BAA0B,EAC3B,GAAGT,oBAAoB;YACtBC,eAAeS;YACfR;QACF;QAEA,2DAA2D;QAC3D,IAAIA,cAAcgB,yBAAyB,EAAE;YAC3CxB,+BAA+B;gBAC7BgB;gBACAR;gBACAE;gBACAI;YACF;QACF;QAEAE,OAAOH,WAAW,GAAGG,OAAOH,WAAW,IAAI,EAAE;QAC7CG,OAAOH,WAAW,GAAGI,OAAOC,MAAM,CAACR;QAEnC,MAAMe,iBAAiBT,OAAOU,MAAM;QAEpCV,OAAOU,MAAM,GAAG,OAAOC;YACrB,IAAI;gBACF,8CAA8C;gBAC9C,IAAIF,gBAAgB;oBAClB,MAAMA,eAAeE;gBACvB;gBAEA,6CAA6C;gBAC7C,MAAMC,OAAO1B,eAAqC;oBAChDyB;oBACAE,QAAQF,QAAQG,EAAE,CAACC,aAAa;oBAChCC,SAAS;wBACP,GAAGjB,0BAA0B;wBAC7BkB,iBAAiBzB,cAAc0B,KAAK,EAAED,mBAAmB;wBACzDE,SAAS;+BAAKpB,2BAA2BoB,OAAO,IAAI,EAAE;yBAAE;oBAC1D;gBACF;gBAEA,iDAAiD;gBACjDlB,OAAOmB,cAAc,CAACT,SAAS,cAAc;oBAC3CU,OAAOT;oBACPU,UAAU;oBACVC,cAAc;gBAChB;YACF,EAAE,OAAOC,OAAO;gBACdC,QAAQD,KAAK,CAAC,oCAAoCA;gBAClD,MAAMA;YACR;QACF;QAEA,OAAOxB;IACT;AACF"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"apply-disabled-default-auth-config.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/plugin/lib/apply-disabled-default-auth-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAQxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEtE;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,EAC7C,MAAM,EACN,aAAa,EACb,aAAa,EACb,yBAAyB,EAC1B,EAAE;IACD,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,kBAAkB,CAAC;IAClC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAChD,yBAAyB,EAAE,iBAAiB,CAAC;CAC9C,GAAG,IAAI,CAqFP"}