@luochuanyuewu/payload-auth 1.8.0

package/dist/better-auth/adapter/transform/index.js

@@ -0,0 +1,729 @@
+import { getAuthTables } from "better-auth/db";
+import { flattenAllFields } from "payload";
+import { getCollectionByModelKey, getCollectionFieldNameByFieldKeyUntyped, getFieldKeyByCollectionFieldName } from "../../plugin/helpers/get-collection";
+export const createTransform = (options, enableDebugLogs)=>{
+    const schema = getAuthTables(options);
+    function debugLog(message) {
+        if (enableDebugLogs) {
+            console.log(`[payload-db-adapter]`, ...message);
+        }
+    }
+    /**
+   * Maps a BetterAuth schema model name to its corresponding Payload CMS collection slug.
+   *
+   * This function resolves the appropriate collection slug by:
+   * 1. Looking up the model in the BetterAuth schema to find its configured modelName
+   * 2. Falling back to the original model name if no mapping exists
+   *
+   * Collection slug resolution follows these rules:
+   * - For base collections: The sanitizeBetterAuthOptions function ensures the collection slug
+   *   from plugin options is set as the model name in the schema
+   * - For plugins: The betterAuthPluginSlugs constant is used as the modelName
+   *
+   * @param model - The BetterAuth model name to resolve
+   * @returns The corresponding Payload CMS collection slug
+   *
+   * @example
+   * // If schema['user'].modelName is 'users'
+   * getCollectionSlug('user') // Returns 'users'
+   *
+   * @example
+   * // If model doesn't exist in schema
+   * getCollectionSlug('custom') // Returns 'custom'
+   *
+   * @warning If a collection is overridden using the collectionOverride option
+   * without updating the schema mapping, this function may return incorrect slugs
+   */ function getCollectionSlug(model) {
+        // First try to get the modelName from schema, otherwise fall back to the original model name
+        const collection = schema?.[model]?.modelName || model;
+        debugLog([
+            "getCollectionSlug:",
+            {
+                model,
+                resolvedSlug: collection
+            }
+        ]);
+        return collection;
+    }
+    /**
+   * Checks if a field in the Payload collection is a relationship or upload field.
+   *
+   * @param payload - The Payload client instance
+   * @param collectionSlug - The slug of the collection
+   * @param fieldName - The name of the field to check
+   * @returns True if the field is a relationship or upload field, false otherwise
+   */ function isPayloadRelationship(payload, collectionSlug, fieldName) {
+        const collection = payload.collections[collectionSlug];
+        if (!collection) return false;
+        const fields = flattenAllFields({
+            fields: collection.config.fields
+        });
+        const field = fields.find((f)=>f.name === fieldName);
+        return field?.type === "relationship" || field?.type === "upload";
+    }
+    /**
+   * Maps a BetterAuth schema field to its corresponding Payload CMS field name.
+   *
+   * This function resolves the appropriate field name by:
+   * 1. Preserving 'id' or '_id' fields as-is (special case handling)
+   * 2. Looking up the field in the BetterAuth schema to find its configured fieldName
+   * 3. Falling back to the original field name if no mapping exists
+   *
+   * @param model - The BetterAuth model name containing the field
+   * @param field - The original field name to resolve
+   * @returns The corresponding Payload CMS field name
+   *
+   * @example
+   * // If schema['user'].fields['email'].fieldName is 'emailAddress'
+   * getFieldName('user', 'email') // Returns 'emailAddress'
+   *
+   * @example
+   * // Special case for ID fields
+   * getFieldName('user', 'id') // Always returns 'id'
+   *
+   * @example
+   * // If field doesn't exist in schema or has no fieldName mapping
+   * getFieldName('user', 'custom') // Returns 'custom'
+   *
+   * @warning If a fieldName is overridden in the payload collection config using the collectionOverride option
+   * without updating the schema mapping, this function may return incorrect field names
+   */ function getFieldName(model, field) {
+        // Special case: 'id' or '_id' is always preserved as-is
+        if ([
+            "id",
+            "_id"
+        ].includes(field)) {
+            return field;
+        }
+        // Look up the field in the schema
+        const fieldDefinition = schema[model]?.fields[field];
+        // Use the configured fieldName if available, otherwise fall back to original
+        const fieldName = fieldDefinition?.fieldName || field;
+        // Log the field resolution for debugging
+        debugLog([
+            "getField: ",
+            {
+                model,
+                originalField: field,
+                fieldName
+            }
+        ]);
+        return fieldName;
+    }
+    /**
+   * Determines if a field is a relationship field by checking for a references property.
+   *
+   * Relationship fields in the schema have a 'references' property that points to another model.
+   * This function checks if this property exists to identify relationship fields.
+   *
+   * @param fieldKey - The key of the field to check in the schema
+   * @param schemaFields - Object containing all fields from the schema for a specific model
+   * @returns True if the field is a relationship field (has references), false otherwise
+   *
+   * @example
+   * // If schema.user.fields.posts has { references: {} }
+   * isRelationshipField('posts', schema.user.fields) // Returns true
+   *
+   * @example
+   * // If schema.user.fields.email has no references property
+   * isRelationshipField('email', schema.user.fields) // Returns false
+   */ function isRelationshipField(fieldKey, schemaFields) {
+        // A field is a relationship field if it has a 'references' property defined
+        return schemaFields[fieldKey]?.references !== undefined;
+    }
+    /**
+   * Extracts a single ID value from a Payload where clause if it represents a simple ID query.
+   *
+   * This function analyzes a Payload where clause to determine if it's a simple query for a
+   * single document by ID. It supports both 'id' and '_id' fields with 'equals' or 'contains'
+   * operators. This is useful for optimizing queries when we only need to fetch a single document.
+   *
+   * @param where - The Payload where clause to analyze
+   * @returns The ID value (string or number) if the where clause is a simple ID query, null otherwise
+   *
+   * @example
+   * // Returns '123' for a simple equals query
+   * singleIdQuery({ id: { equals: '123' } }) // '123'
+   *
+   * @example
+   * // Returns 456 for a simple equals query with number ID
+   * singleIdQuery({ _id: { equals: 456 } }) // 456
+   *
+   * @example
+   * // Returns '789' for a contains query with a single value
+   * singleIdQuery({ id: { contains: ['789'] } }) // '789'
+   *
+   * @example
+   * // Returns null for complex queries
+   * singleIdQuery({ and: [{ id: { equals: '123' } }] }) // null
+   */ function singleIdQuery(where) {
+        // Return null for empty where clauses or complex queries with 'and'/'or' operators
+        if (!where || "and" in where || "or" in where) return null;
+        // Check if the where clause contains either 'id' or '_id' field
+        if ([
+            "id",
+            "_id"
+        ].some((field)=>field in where)) {
+            // Determine which ID field is being used (support both 'id' and '_id')
+            const idField = "id" in where ? "id" : "_id";
+            const condition = where[idField];
+            // Process the equals operator case
+            if (condition && typeof condition === "object" && !Array.isArray(condition) && "equals" in condition) {
+                const value = condition.equals;
+                // Only return string or number ID values
+                if (typeof value === "string" || typeof value === "number") {
+                    return value;
+                }
+            }
+            // Process the contains operator case with a single value
+            if (condition && typeof condition === "object" && !Array.isArray(condition) && "contains" in condition && Array.isArray(condition.contains) && condition.contains.length === 1) {
+                const value = condition.contains[0];
+                // Only return string or number ID values
+                if (typeof value === "string" || typeof value === "number") {
+                    return value;
+                }
+            }
+        }
+        // Return null if no valid ID query was found
+        return null;
+    }
+    /**
+   * Normalizes data values based on field type and required ID type
+   *
+   * This function handles type conversion for relationship fields to ensure
+   * IDs are in the correct format (string or number) based on the configuration.
+   *
+   * @param key - The field key/name
+   * @param value - The value to normalize
+   * @param isRelatedField - Whether this field is a relationship field
+   * @param idType - The expected ID type ('number' or 'text')
+   * @returns The normalized value
+   */ function normalizeData({ key, value, isRelatedField, idType }) {
+        // Skip processing for null/undefined values
+        if (value === null || value === undefined) {
+            return value;
+        }
+        if ([
+            "id",
+            "_id"
+        ].includes(key)) {
+            if (typeof value === "string" && idType === "number") {
+                const parsed = parseInt(value, 10);
+                if (!isNaN(parsed)) {
+                    debugLog([
+                        `ID conversion: ${key} converting string ID to number`,
+                        {
+                            original: value,
+                            converted: parsed
+                        }
+                    ]);
+                    return parsed;
+                }
+            }
+            if (typeof value === "number" && idType === "text") {
+                const stringId = String(value);
+                debugLog([
+                    `ID conversion: ${key} converting number ID to string`,
+                    {
+                        original: value,
+                        converted: stringId
+                    }
+                ]);
+                return stringId;
+            }
+        }
+        // Only process relationship fields that need type conversion
+        if (isRelatedField) {
+            // Handle single ID value conversion
+            if (typeof value === "string" && idType === "number") {
+                const parsed = parseInt(value, 10);
+                if (!isNaN(parsed)) {
+                    debugLog([
+                        `ID conversion: ${key} converting string ID to number`,
+                        {
+                            original: value,
+                            converted: parsed
+                        }
+                    ]);
+                    return parsed;
+                }
+            } else if (typeof value === "number" && idType === "text") {
+                const stringId = String(value);
+                debugLog([
+                    `ID conversion: ${key} converting number ID to string`,
+                    {
+                        original: value,
+                        converted: stringId
+                    }
+                ]);
+                return stringId;
+            }
+            // Handle array of IDs - map each value to the correct type
+            if (Array.isArray(value)) {
+                return value.map((id)=>{
+                    // Skip null/undefined values in arrays
+                    if (id === null || id === undefined) return id;
+                    if (idType === "number" && typeof id === "string") {
+                        const parsed = parseInt(id, 10);
+                        return !isNaN(parsed) ? parsed : id;
+                    } else if (idType === "text" && typeof id === "number") {
+                        return String(id);
+                    }
+                    return id;
+                });
+            }
+        }
+        // Handle role fields (Coming from better auth, will be a single string seperated by commas if theres multiple roles)
+        if (key === "role" || key === "roles") {
+            return value.split(",").map((role)=>role.trim().toLowerCase());
+        }
+        // Return original value if no conversion was needed or applicable
+        return value;
+    }
+    /**
+   * Transforms input data from better-auth to Payload CMS format
+   *
+   * This function handles:
+   * 1. Field name mapping according to schema definitions
+   * 2. ID type conversion for relationship fields
+   * 3. Proper data normalization based on field types
+   *
+   * @param data - The input data from better-auth
+   * @param model - The model name in the schema
+   * @param idType - The expected ID type ('number' or 'text')
+   * @returns Transformed data compatible with Payload CMS
+   */ function transformInput({ data, model, idType, payload }) {
+        const transformedData = {};
+        const schemaFields = schema?.[model]?.fields ?? {};
+        // Process each field in the input data
+        Object.entries(data).forEach(([key, value])=>{
+            // Skip null/undefined values
+            if (value === null || value === undefined) {
+                return;
+            }
+            // Get the mapped field name from schema (if any)
+            const schemaFieldName = schemaFields[key]?.fieldName;
+            const targetFieldName = schemaFieldName || key;
+            // Check Payload schema for relationship fields
+            const collectionSlug = getCollectionSlug(model);
+            const isPayloadRel = isPayloadRelationship(payload, collectionSlug, targetFieldName);
+            // Determine if this is a relationship field
+            const isRelatedField = isRelationshipField(key, schemaFields) || isPayloadRel;
+            // Normalize the data value based on field type and ID type
+            const normalizedData = normalizeData({
+                idType,
+                key,
+                value,
+                isRelatedField
+            });
+            const targetFieldKey = getCollectionFieldNameByFieldKeyUntyped(getCollectionByModelKey(payload.collections, model), targetFieldName);
+            transformedData[targetFieldKey] = normalizedData;
+        });
+        return transformedData;
+    }
+    /**
+   * Checks if a value is a Payload join result (has docs array structure)
+   */ function isJoinResult(value) {
+        return value !== null && typeof value === "object" && "docs" in value && Array.isArray(value.docs);
+    }
+    /**
+   * Flattens a Payload join result to just the array of documents.
+   * Handles both direct documents and polymorphic { relationTo, value } format.
+   */ function flattenJoinResult(joinResult) {
+        return joinResult.docs.map((item)=>{
+            // Handle polymorphic join format: { relationTo: string, value: doc }
+            if (item && typeof item === "object" && "value" in item && "relationTo" in item) {
+                return item.value;
+            }
+            return item;
+        });
+    }
+    /**
+   * Transforms Payload CMS document output to match BetterAuth schema expectations.
+   *
+   * This function handles several critical transformations:
+   *
+   * 1. ID Conversion: Ensures all ID fields are strings as required by BetterAuth
+   *    (see: https://github.com/better-auth/better-auth/blob/main/packages/better-auth/src/db/schema.ts#L125)
+   *
+   * 2. Relationship Field Mapping: Aligns relationship fields with BetterAuth schema naming conventions
+   *    and ensures proper ID type handling
+   *
+   * 3. Date Conversion: Transforms date strings from Payload into Date objects for BetterAuth
+   *
+   * 4. Join Result Flattening: Converts Payload's { docs: [...] } join format to plain arrays
+   *
+   * Note: While setting depth: 1 in Payload operations simplifies this process by avoiding
+   * deeply nested objects, we maintain comprehensive checks for robustness.
+   *
+   * @param doc - The document returned from Payload CMS
+   * @param model - The model name in the BetterAuth schema
+   * @returns The transformed document compatible with BetterAuth
+   */ function transformOutput({ doc, model, payload }) {
+        if (!doc || typeof doc !== "object") return doc;
+        const result = {
+            ...doc
+        };
+        const schemaFields = schema?.[model]?.fields ?? {};
+        // Identify relationship fields with custom field name mappings
+        const relationshipFields = Object.fromEntries(Object.entries(schemaFields).filter(([key])=>{
+            if (isRelationshipField(key, schemaFields)) return true;
+            // Also check payload schema
+            const fieldName = schemaFields[key]?.fieldName || key;
+            const collectionSlug = getCollectionSlug(model);
+            return isPayloadRelationship(payload, collectionSlug, fieldName);
+        }));
+        const dateFields = Object.fromEntries(Object.entries(schemaFields).filter(([_, value])=>value.type === "date"));
+        // First make sure all the fields keys are correct
+        Object.keys(result).forEach((key)=>{
+            const targetFieldKey = getFieldKeyByCollectionFieldName(getCollectionByModelKey(payload.collections, model), key);
+            if (targetFieldKey !== key) {
+                result[targetFieldKey] = result[key];
+                delete result[key];
+            }
+        });
+        Object.entries(doc).forEach(([key, value])=>{
+            if (value === null || value === undefined) return;
+            const targetFieldKey = getFieldKeyByCollectionFieldName(getCollectionByModelKey(payload.collections, model), key);
+            // Convert ID fields to strings for BetterAuth compatibility
+            if ([
+                "id",
+                "_id"
+            ].includes(key)) {
+                result[targetFieldKey] = String(value);
+                return;
+            }
+            // Flatten join results from { docs: [...] } to plain arrays
+            if (isJoinResult(value)) {
+                debugLog([
+                    "transformOutput: flattening join result",
+                    {
+                        key,
+                        targetFieldKey,
+                        isArray: Array.isArray(value.docs)
+                    }
+                ]);
+                result[targetFieldKey] = flattenJoinResult(value);
+                return;
+            }
+            // Handle relationship fields with renamed fieldNames
+            const originalRelatedFieldKey = Object.keys(relationshipFields).find((k)=>relationshipFields[k].fieldName === key);
+            if (originalRelatedFieldKey) {
+                normalizeDocumentIds(result, originalRelatedFieldKey, key, value);
+                return;
+            }
+            const originalDateFieldKey = Object.keys(dateFields).find((k)=>dateFields[k].fieldName === key);
+            if (originalDateFieldKey) {
+                // Convert ISO date strings to Date objects for BetterAuth
+                result[targetFieldKey] = new Date(value);
+                return;
+            }
+        });
+        return result;
+    }
+    /**
+   * Normalizes ID fields for both primary and relationship documents.
+   *
+   * This function ensures consistent ID handling between BetterAuth and Payload CMS by:
+   * 1. Converting all IDs to strings for BetterAuth (stored in originalKey)
+   * 2. Preserving original ID types for Payload CMS (stored in fieldName)
+   *
+   * The function handles various ID formats:
+   * - Primitive values (string/number IDs)
+   * - Object references with ID properties
+   * - Arrays of either primitive IDs or object references
+   *
+   * @param result - The result object being transformed
+   * @param originalKey - The original field key from BetterAuth schema
+   * @param fieldName - The renamed field as used in Payload CMS
+   * @param value - The ID value to normalize (primitive, object, or array)
+   */ function normalizeDocumentIds(result, originalKey, fieldName, value) {
+        // Case 1: Primitive ID value (string or number)
+        if (typeof value === "string" || typeof value === "number") {
+            // For BetterAuth: Always use string IDs
+            result[originalKey] = String(value);
+            // For Payload: Keep original type
+            result[fieldName] = value;
+            return;
+        }
+        // Case 2: Object with ID property
+        if (typeof value === "object" && value !== null && !Array.isArray(value) && "id" in value) {
+            // For BetterAuth: Extract and stringify the ID
+            result[originalKey] = String(value.id);
+            // Preserve the populated relationship object so joins return full documents
+            result[fieldName] = {
+                ...value,
+                id: String(value.id)
+            };
+            return;
+        }
+        // Case 3: Array of IDs or references
+        if (Array.isArray(value) && value.length > 0) {
+            // Check if array contains objects with ID properties
+            if (value.every((item)=>typeof item === "object" && item !== null && "id" in item)) {
+                // Array of objects with IDs
+                result[originalKey] = value.map((item)=>String(item.id));
+                // Keep joined documents intact while normalizing ID type
+                result[fieldName] = value.map((item)=>({
+                        ...item,
+                        id: String(item.id)
+                    }));
+            } else {
+                // Array of primitive IDs
+                result[originalKey] = value.map((item)=>String(item));
+                result[fieldName] = value.map((item)=>item);
+            }
+            return;
+        }
+    // Note: If value doesn't match any expected format, no changes are made
+    }
+    /**
+   * Converts a BetterAuth operator to the equivalent Payload CMS query operator
+   *
+   * This function maps standard query operators from BetterAuth's format to
+   * the specific format expected by Payload CMS's query engine.
+   *
+   * @param operator - The BetterAuth operator string (e.g., 'eq', 'gt', 'contains')
+   * @param value - The value to be used with the operator
+   * @returns An object with the Payload-compatible operator and value
+   *
+   * @example
+   * // Returns { equals: 'test@example.com' }
+   * operatorToPayload('eq', 'test@example.com')
+   *
+   * @example
+   * // Returns { greater_than: 100 }
+   * operatorToPayload('gt', 100)
+   */ function operatorToPayload(operator, value) {
+        switch(operator){
+            case "eq":
+                return {
+                    equals: value
+                };
+            case "ne":
+                return {
+                    not_equals: value
+                };
+            case "gt":
+                return {
+                    greater_than: value
+                };
+            case "gte":
+                return {
+                    greater_than_equal: value
+                };
+            case "lt":
+                return {
+                    less_than: value
+                };
+            case "lte":
+                return {
+                    less_than_equal: value
+                };
+            case "contains":
+                return {
+                    contains: value
+                };
+            case "in":
+                return {
+                    in: value
+                };
+            case "starts_with":
+                return {
+                    like: `${value}%`
+                };
+            case "ends_with":
+                return {
+                    like: `%${value}`
+                };
+            default:
+                // Fall back to equals for unrecognized operators
+                return {
+                    equals: value
+                };
+        }
+    }
+    /**
+   * Converts a where clause value to the appropriate type based on field name and ID type configuration
+   *
+   * This function handles two main scenarios:
+   * 1. ID field conversion - ensures IDs match the database's expected type (number or string)
+   * 2. Object with embedded ID - extracts and converts the ID property from objects
+   *
+   * @param value - The value to convert (can be primitive, object with ID, or array)
+   * @param fieldName - The name of the field being queried
+   * @param idType - The expected ID type in the database
+   * @returns The converted value appropriate for the database query
+   */ function convertWhereValue({ value, fieldName, idType }) {
+        // Check if field is an ID field (supporting both MongoDB-style _id and standard id)
+        if ([
+            "id",
+            "_id"
+        ].includes(fieldName)) {
+            // Case 1: Value is an object containing an ID property
+            if (typeof value === "object" && value !== null && "id" in value) {
+                // Extract ID from object
+                const id = value.id;
+                // Use type conversion based on database configuration
+                if (idType === "number" && typeof id === "string") {
+                    const numId = Number(id);
+                    return !isNaN(numId) ? numId : id;
+                }
+                if (idType === "text" && typeof id === "number") {
+                    return String(id);
+                }
+                return id;
+            }
+            // Case 2: Value is a standalone ID that needs type conversion
+            // Convert string ID to number if database expects numeric IDs
+            if (idType === "number" && typeof value === "string" && !isNaN(Number(value))) {
+                return Number(value);
+            } else if (idType === "text" && typeof value === "number") {
+                return String(value);
+            }
+            return value;
+        }
+        // For non-ID fields, return the value unchanged
+        return value;
+    }
+    /**
+   * Converts Better Auth where clauses to Payload CMS compatible where conditions
+   *
+   * This function transforms the Better Auth query format into Payload's query format,
+   * handling field name mapping, value type conversion, and logical operators (AND/OR).
+   *
+   * The function handles three main cases:
+   * 1. Empty or undefined where clause - returns empty object
+   * 2. Single condition - converts to a simple field-value pair
+   * 3. Multiple conditions - groups by AND/OR connectors and builds a complex query
+   *
+   * @param idType - The database ID type ('number' or 'text')
+   * @param model - The model/collection name to query
+   * @param where - Array of Better Auth where conditions
+   * @returns A Payload-compatible where clause object
+   */ function convertWhereClause({ idType, model, where, payload }) {
+        // Handle empty where clause
+        if (!where) return {};
+        function getPayloadFieldName(fieldKey) {
+            return getCollectionFieldNameByFieldKeyUntyped(getCollectionByModelKey(payload.collections, model), fieldKey);
+        }
+        // Handle single condition case for optimization
+        if (where.length === 1) {
+            const w = where[0];
+            if (!w) {
+                return {};
+            }
+            // Map field name according to schema and convert value to appropriate type
+            const fieldName = getFieldName(model, w.field);
+            const value = convertWhereValue({
+                value: w.value,
+                fieldName,
+                idType
+            });
+            // Create the Payload where condition with proper operator
+            const res = {
+                [getPayloadFieldName(fieldName)]: operatorToPayload(w.operator ?? "", value)
+            };
+            return res;
+        }
+        // Handle multiple conditions by separating AND/OR clauses
+        // Default to AND if no connector is specified
+        const and = where.filter((w)=>w.connector === "AND" || !w.connector);
+        const or = where.filter((w)=>w.connector === "OR");
+        // Process AND conditions
+        const andClause = and.map((w)=>{
+            const fieldName = getFieldName(model, w.field);
+            const value = convertWhereValue({
+                value: w.value,
+                fieldName,
+                idType
+            });
+            return {
+                [getPayloadFieldName(fieldName)]: operatorToPayload(w.operator ?? "", value)
+            };
+        });
+        // Process OR conditions
+        const orClause = or.map((w)=>{
+            const fieldName = getFieldName(model, w.field);
+            const value = convertWhereValue({
+                value: w.value,
+                fieldName,
+                idType
+            });
+            return {
+                [getPayloadFieldName(fieldName)]: operatorToPayload(w.operator ?? "", value)
+            };
+        });
+        // Combine AND and OR clauses into final Payload where object
+        // Only include non-empty clause arrays
+        return {
+            ...andClause.length ? {
+                AND: andClause
+            } : {},
+            ...orClause.length ? {
+                OR: orClause
+            } : {}
+        };
+    }
+    /**
+   * Converts a better-auth select array to a Payload select object
+   *
+   * This function transforms the better-auth select array (which contains field names)
+   * into the format expected by Payload CMS's query API (an object with field names as keys
+   * and boolean true as values).
+   *
+   * It also handles field name mapping between better-auth schema and Payload collections
+   * by using the getFieldName helper to resolve the correct field names.
+   *
+   * @param model - The model/collection name to get field mappings from
+   * @param select - Optional array of field names to select
+   * @returns A Payload-compatible select object or undefined if no fields to select
+   * @example
+   * // Input: ['email', 'name']
+   * // Output: { email: true, name: true }
+   */ function convertSelect(model, select) {
+        // Return undefined if select is empty or not provided
+        if (!select || select.length === 0) return undefined;
+        // Transform the array of field names into a Payload select object
+        // while also mapping any field names that might be different in Payload
+        return select.reduce((acc, field)=>({
+                ...acc,
+                [getFieldName(model, field)]: true
+            }), {});
+    }
+    /**
+   * Converts a better-auth sort object to a Payload sort string
+   *
+   * This function transforms the better-auth sort object (which contains field name and direction)
+   * into the format expected by Payload CMS's query API (a string with optional '-' prefix for descending order).
+   *
+   * It also handles field name mapping between better-auth schema and Payload collections
+   * by using the getFieldName helper to resolve the correct field names.
+   *
+   * @param model - The model/collection name to get field mappings from
+   * @param sortBy - Optional object containing field name and sort direction
+   * @returns A Payload-compatible sort string or undefined if no sort specified
+   * @example
+   * // Input: { field: 'email', direction: 'desc' }
+   * // Output: '-email'
+   * // Input: { field: 'createdAt', direction: 'asc' }
+   * // Output: 'createdAt'
+   */ function convertSort(model, sortBy) {
+        if (!sortBy) return undefined;
+        const fieldName = getFieldName(model, sortBy.field);
+        const prefix = sortBy.direction === "desc" ? "-" : "";
+        return `${prefix}${fieldName}`;
+    }
+    return {
+        getFieldName,
+        getCollectionSlug,
+        singleIdQuery,
+        transformInput,
+        transformOutput,
+        convertWhereClause,
+        convertSelect,
+        convertSort
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/better-auth/adapter/transform/index.ts"],"sourcesContent":["import type { BetterAuthOptions, Where } from \"better-auth\";\nimport type { DBFieldAttribute } from \"better-auth/db\";\nimport { getAuthTables } from \"better-auth/db\";\nimport {\n  type BasePayload,\n  type CollectionSlug,\n  flattenAllFields,\n  type Where as PayloadWhere\n} from \"payload\";\nimport type { ModelKey } from \"@/better-auth/generated-types\";\nimport {\n  getCollectionByModelKey,\n  getCollectionFieldNameByFieldKeyUntyped,\n  getFieldKeyByCollectionFieldName\n} from \"@/better-auth/plugin/helpers/get-collection\";\n\nexport const createTransform = (\n  options: BetterAuthOptions,\n  enableDebugLogs: boolean\n) => {\n  const schema = getAuthTables(options);\n\n  function debugLog(message: any[]) {\n    if (enableDebugLogs) {\n      console.log(`[payload-db-adapter]`, ...message);\n    }\n  }\n\n  /**\n   * Maps a BetterAuth schema model name to its corresponding Payload CMS collection slug.\n   *\n   * This function resolves the appropriate collection slug by:\n   * 1. Looking up the model in the BetterAuth schema to find its configured modelName\n   * 2. Falling back to the original model name if no mapping exists\n   *\n   * Collection slug resolution follows these rules:\n   * - For base collections: The sanitizeBetterAuthOptions function ensures the collection slug\n   *   from plugin options is set as the model name in the schema\n   * - For plugins: The betterAuthPluginSlugs constant is used as the modelName\n   *\n   * @param model - The BetterAuth model name to resolve\n   * @returns The corresponding Payload CMS collection slug\n   *\n   * @example\n   * // If schema['user'].modelName is 'users'\n   * getCollectionSlug('user') // Returns 'users'\n   *\n   * @example\n   * // If model doesn't exist in schema\n   * getCollectionSlug('custom') // Returns 'custom'\n   *\n   * @warning If a collection is overridden using the collectionOverride option\n   * without updating the schema mapping, this function may return incorrect slugs\n   */\n  function getCollectionSlug(model: ModelKey): CollectionSlug {\n    // First try to get the modelName from schema, otherwise fall back to the original model name\n    const collection = schema?.[model]?.modelName || model;\n    debugLog([\"getCollectionSlug:\", { model, resolvedSlug: collection }]);\n    return collection as CollectionSlug;\n  }\n\n  /**\n   * Checks if a field in the Payload collection is a relationship or upload field.\n   *\n   * @param payload - The Payload client instance\n   * @param collectionSlug - The slug of the collection\n   * @param fieldName - The name of the field to check\n   * @returns True if the field is a relationship or upload field, false otherwise\n   */\n  function isPayloadRelationship(\n    payload: BasePayload,\n    collectionSlug: string,\n    fieldName: string\n  ): boolean {\n    const collection = payload.collections[collectionSlug];\n    if (!collection) return false;\n\n    const fields = flattenAllFields({ fields: collection.config.fields });\n    const field = fields.find((f) => f.name === fieldName);\n\n    return field?.type === \"relationship\" || field?.type === \"upload\";\n  }\n\n  /**\n   * Maps a BetterAuth schema field to its corresponding Payload CMS field name.\n   *\n   * This function resolves the appropriate field name by:\n   * 1. Preserving 'id' or '_id' fields as-is (special case handling)\n   * 2. Looking up the field in the BetterAuth schema to find its configured fieldName\n   * 3. Falling back to the original field name if no mapping exists\n   *\n   * @param model - The BetterAuth model name containing the field\n   * @param field - The original field name to resolve\n   * @returns The corresponding Payload CMS field name\n   *\n   * @example\n   * // If schema['user'].fields['email'].fieldName is 'emailAddress'\n   * getFieldName('user', 'email') // Returns 'emailAddress'\n   *\n   * @example\n   * // Special case for ID fields\n   * getFieldName('user', 'id') // Always returns 'id'\n   *\n   * @example\n   * // If field doesn't exist in schema or has no fieldName mapping\n   * getFieldName('user', 'custom') // Returns 'custom'\n   *\n   * @warning If a fieldName is overridden in the payload collection config using the collectionOverride option\n   * without updating the schema mapping, this function may return incorrect field names\n   */\n  function getFieldName(model: ModelKey, field: string): string {\n    // Special case: 'id' or '_id' is always preserved as-is\n    if ([\"id\", \"_id\"].includes(field)) {\n      return field;\n    }\n\n    // Look up the field in the schema\n    const fieldDefinition = schema[model]?.fields[field];\n\n    // Use the configured fieldName if available, otherwise fall back to original\n    const fieldName = fieldDefinition?.fieldName || field;\n\n    // Log the field resolution for debugging\n    debugLog([\"getField: \", { model, originalField: field, fieldName }]);\n\n    return fieldName;\n  }\n\n  /**\n   * Determines if a field is a relationship field by checking for a references property.\n   *\n   * Relationship fields in the schema have a 'references' property that points to another model.\n   * This function checks if this property exists to identify relationship fields.\n   *\n   * @param fieldKey - The key of the field to check in the schema\n   * @param schemaFields - Object containing all fields from the schema for a specific model\n   * @returns True if the field is a relationship field (has references), false otherwise\n   *\n   * @example\n   * // If schema.user.fields.posts has { references: {} }\n   * isRelationshipField('posts', schema.user.fields) // Returns true\n   *\n   * @example\n   * // If schema.user.fields.email has no references property\n   * isRelationshipField('email', schema.user.fields) // Returns false\n   */\n  function isRelationshipField(\n    fieldKey: string,\n    schemaFields: Record<string, DBFieldAttribute>\n  ): boolean {\n    // A field is a relationship field if it has a 'references' property defined\n    return schemaFields[fieldKey]?.references !== undefined;\n  }\n  /**\n   * Extracts a single ID value from a Payload where clause if it represents a simple ID query.\n   *\n   * This function analyzes a Payload where clause to determine if it's a simple query for a\n   * single document by ID. It supports both 'id' and '_id' fields with 'equals' or 'contains'\n   * operators. This is useful for optimizing queries when we only need to fetch a single document.\n   *\n   * @param where - The Payload where clause to analyze\n   * @returns The ID value (string or number) if the where clause is a simple ID query, null otherwise\n   *\n   * @example\n   * // Returns '123' for a simple equals query\n   * singleIdQuery({ id: { equals: '123' } }) // '123'\n   *\n   * @example\n   * // Returns 456 for a simple equals query with number ID\n   * singleIdQuery({ _id: { equals: 456 } }) // 456\n   *\n   * @example\n   * // Returns '789' for a contains query with a single value\n   * singleIdQuery({ id: { contains: ['789'] } }) // '789'\n   *\n   * @example\n   * // Returns null for complex queries\n   * singleIdQuery({ and: [{ id: { equals: '123' } }] }) // null\n   */\n  function singleIdQuery(where: PayloadWhere) {\n    // Return null for empty where clauses or complex queries with 'and'/'or' operators\n    if (!where || \"and\" in where || \"or\" in where) return null;\n\n    // Check if the where clause contains either 'id' or '_id' field\n    if ([\"id\", \"_id\"].some((field) => field in where)) {\n      // Determine which ID field is being used (support both 'id' and '_id')\n      const idField = \"id\" in where ? \"id\" : \"_id\";\n      const condition = where[idField];\n\n      // Process the equals operator case\n      if (\n        condition &&\n        typeof condition === \"object\" &&\n        !Array.isArray(condition) &&\n        \"equals\" in condition\n      ) {\n        const value = condition.equals;\n        // Only return string or number ID values\n        if (typeof value === \"string\" || typeof value === \"number\") {\n          return value;\n        }\n      }\n\n      // Process the contains operator case with a single value\n      if (\n        condition &&\n        typeof condition === \"object\" &&\n        !Array.isArray(condition) &&\n        \"contains\" in condition &&\n        Array.isArray(condition.contains) &&\n        condition.contains.length === 1\n      ) {\n        const value = condition.contains[0];\n        // Only return string or number ID values\n        if (typeof value === \"string\" || typeof value === \"number\") {\n          return value;\n        }\n      }\n    }\n\n    // Return null if no valid ID query was found\n    return null;\n  }\n\n  /**\n   * Normalizes data values based on field type and required ID type\n   *\n   * This function handles type conversion for relationship fields to ensure\n   * IDs are in the correct format (string or number) based on the configuration.\n   *\n   * @param key - The field key/name\n   * @param value - The value to normalize\n   * @param isRelatedField - Whether this field is a relationship field\n   * @param idType - The expected ID type ('number' or 'text')\n   * @returns The normalized value\n   */\n  function normalizeData({\n    key,\n    value,\n    isRelatedField,\n    idType\n  }: {\n    key: string;\n    value: any;\n    isRelatedField: boolean;\n    idType: \"number\" | \"text\";\n  }) {\n    // Skip processing for null/undefined values\n    if (value === null || value === undefined) {\n      return value;\n    }\n\n    if ([\"id\", \"_id\"].includes(key)) {\n      if (typeof value === \"string\" && idType === \"number\") {\n        const parsed = parseInt(value, 10);\n        if (!isNaN(parsed)) {\n          debugLog([\n            `ID conversion: ${key} converting string ID to number`,\n            { original: value, converted: parsed }\n          ]);\n          return parsed;\n        }\n      }\n      if (typeof value === \"number\" && idType === \"text\") {\n        const stringId = String(value);\n        debugLog([\n          `ID conversion: ${key} converting number ID to string`,\n          { original: value, converted: stringId }\n        ]);\n        return stringId;\n      }\n    }\n\n    // Only process relationship fields that need type conversion\n    if (isRelatedField) {\n      // Handle single ID value conversion\n      if (typeof value === \"string\" && idType === \"number\") {\n        const parsed = parseInt(value, 10);\n        if (!isNaN(parsed)) {\n          debugLog([\n            `ID conversion: ${key} converting string ID to number`,\n            { original: value, converted: parsed }\n          ]);\n          return parsed;\n        }\n      } else if (typeof value === \"number\" && idType === \"text\") {\n        const stringId = String(value);\n        debugLog([\n          `ID conversion: ${key} converting number ID to string`,\n          { original: value, converted: stringId }\n        ]);\n        return stringId;\n      }\n\n      // Handle array of IDs - map each value to the correct type\n      if (Array.isArray(value)) {\n        return value.map((id) => {\n          // Skip null/undefined values in arrays\n          if (id === null || id === undefined) return id;\n\n          if (idType === \"number\" && typeof id === \"string\") {\n            const parsed = parseInt(id, 10);\n            return !isNaN(parsed) ? parsed : id;\n          } else if (idType === \"text\" && typeof id === \"number\") {\n            return String(id);\n          }\n          return id;\n        });\n      }\n    }\n\n    // Handle role fields (Coming from better auth, will be a single string seperated by commas if theres multiple roles)\n    if (key === \"role\" || key === \"roles\") {\n      return value.split(\",\").map((role: string) => role.trim().toLowerCase());\n    }\n\n    // Return original value if no conversion was needed or applicable\n    return value;\n  }\n\n  /**\n   * Transforms input data from better-auth to Payload CMS format\n   *\n   * This function handles:\n   * 1. Field name mapping according to schema definitions\n   * 2. ID type conversion for relationship fields\n   * 3. Proper data normalization based on field types\n   *\n   * @param data - The input data from better-auth\n   * @param model - The model name in the schema\n   * @param idType - The expected ID type ('number' or 'text')\n   * @returns Transformed data compatible with Payload CMS\n   */\n  function transformInput({\n    data,\n    model,\n    idType,\n    payload\n  }: {\n    data: Record<string, any>;\n    model: ModelKey;\n    idType: \"number\" | \"text\";\n    payload: BasePayload;\n  }): Record<string, any> {\n    const transformedData: Record<string, any> = {};\n    const schemaFields = schema?.[model]?.fields ?? {};\n\n    // Process each field in the input data\n    Object.entries(data).forEach(([key, value]) => {\n      // Skip null/undefined values\n      if (value === null || value === undefined) {\n        return;\n      }\n\n      // Get the mapped field name from schema (if any)\n      const schemaFieldName = schemaFields[key]?.fieldName;\n      const targetFieldName = schemaFieldName || key;\n\n      // Check Payload schema for relationship fields\n      const collectionSlug = getCollectionSlug(model);\n      const isPayloadRel = isPayloadRelationship(\n        payload,\n        collectionSlug,\n        targetFieldName\n      );\n\n      // Determine if this is a relationship field\n      const isRelatedField =\n        isRelationshipField(key, schemaFields) || isPayloadRel;\n\n      // Normalize the data value based on field type and ID type\n      const normalizedData = normalizeData({\n        idType,\n        key,\n        value,\n        isRelatedField\n      });\n\n      const targetFieldKey = getCollectionFieldNameByFieldKeyUntyped(\n        getCollectionByModelKey(payload.collections, model),\n        targetFieldName\n      );\n      transformedData[targetFieldKey] = normalizedData;\n    });\n\n    return transformedData;\n  }\n\n  /**\n   * Checks if a value is a Payload join result (has docs array structure)\n   */\n  function isJoinResult(\n    value: any\n  ): value is { docs: any[]; hasNextPage?: boolean; totalDocs?: number } {\n    return (\n      value !== null &&\n      typeof value === \"object\" &&\n      \"docs\" in value &&\n      Array.isArray(value.docs)\n    );\n  }\n\n  /**\n   * Flattens a Payload join result to just the array of documents.\n   * Handles both direct documents and polymorphic { relationTo, value } format.\n   */\n  function flattenJoinResult(joinResult: { docs: any[] }): any[] {\n    return joinResult.docs.map((item) => {\n      // Handle polymorphic join format: { relationTo: string, value: doc }\n      if (\n        item &&\n        typeof item === \"object\" &&\n        \"value\" in item &&\n        \"relationTo\" in item\n      ) {\n        return item.value;\n      }\n      return item;\n    });\n  }\n\n  /**\n   * Transforms Payload CMS document output to match BetterAuth schema expectations.\n   *\n   * This function handles several critical transformations:\n   *\n   * 1. ID Conversion: Ensures all ID fields are strings as required by BetterAuth\n   *    (see: https://github.com/better-auth/better-auth/blob/main/packages/better-auth/src/db/schema.ts#L125)\n   *\n   * 2. Relationship Field Mapping: Aligns relationship fields with BetterAuth schema naming conventions\n   *    and ensures proper ID type handling\n   *\n   * 3. Date Conversion: Transforms date strings from Payload into Date objects for BetterAuth\n   *\n   * 4. Join Result Flattening: Converts Payload's { docs: [...] } join format to plain arrays\n   *\n   * Note: While setting depth: 1 in Payload operations simplifies this process by avoiding\n   * deeply nested objects, we maintain comprehensive checks for robustness.\n   *\n   * @param doc - The document returned from Payload CMS\n   * @param model - The model name in the BetterAuth schema\n   * @returns The transformed document compatible with BetterAuth\n   */\n  function transformOutput<T extends Record<string, any> | null>({\n    doc,\n    model,\n    payload\n  }: {\n    doc: T;\n    model: ModelKey;\n    payload: BasePayload;\n  }): T {\n    if (!doc || typeof doc !== \"object\") return doc;\n\n    const result = { ...doc };\n    const schemaFields = schema?.[model]?.fields ?? {};\n\n    // Identify relationship fields with custom field name mappings\n    const relationshipFields = Object.fromEntries(\n      Object.entries(schemaFields).filter(([key]) => {\n        if (isRelationshipField(key, schemaFields)) return true;\n\n        // Also check payload schema\n        const fieldName = schemaFields[key]?.fieldName || key;\n        const collectionSlug = getCollectionSlug(model);\n        return isPayloadRelationship(payload, collectionSlug, fieldName);\n      })\n    );\n    const dateFields = Object.fromEntries(\n      Object.entries(schemaFields).filter(([_, value]) => value.type === \"date\")\n    );\n\n    // First make sure all the fields keys are correct\n    Object.keys(result).forEach((key) => {\n      const targetFieldKey = getFieldKeyByCollectionFieldName(\n        getCollectionByModelKey(payload.collections, model),\n        key\n      );\n      if (targetFieldKey !== key) {\n        result[targetFieldKey] = result[key];\n        delete result[key];\n      }\n    });\n\n    Object.entries(doc).forEach(([key, value]) => {\n      if (value === null || value === undefined) return;\n\n      const targetFieldKey = getFieldKeyByCollectionFieldName(\n        getCollectionByModelKey(payload.collections, model),\n        key\n      );\n\n      // Convert ID fields to strings for BetterAuth compatibility\n      if ([\"id\", \"_id\"].includes(key)) {\n        result[targetFieldKey] = String(value);\n        return;\n      }\n\n      // Flatten join results from { docs: [...] } to plain arrays\n      if (isJoinResult(value)) {\n        debugLog([\n          \"transformOutput: flattening join result\",\n          { key, targetFieldKey, isArray: Array.isArray(value.docs) }\n        ]);\n        result[targetFieldKey] = flattenJoinResult(value);\n        return;\n      }\n\n      // Handle relationship fields with renamed fieldNames\n      const originalRelatedFieldKey = Object.keys(relationshipFields).find(\n        (k) => relationshipFields[k].fieldName === key\n      );\n      if (originalRelatedFieldKey) {\n        normalizeDocumentIds(result, originalRelatedFieldKey, key, value);\n        return;\n      }\n\n      const originalDateFieldKey = Object.keys(dateFields).find(\n        (k) => dateFields[k].fieldName === key\n      );\n      if (originalDateFieldKey) {\n        // Convert ISO date strings to Date objects for BetterAuth\n        result[targetFieldKey] = new Date(value);\n        return;\n      }\n    });\n\n    return result as T;\n  }\n\n  /**\n   * Normalizes ID fields for both primary and relationship documents.\n   *\n   * This function ensures consistent ID handling between BetterAuth and Payload CMS by:\n   * 1. Converting all IDs to strings for BetterAuth (stored in originalKey)\n   * 2. Preserving original ID types for Payload CMS (stored in fieldName)\n   *\n   * The function handles various ID formats:\n   * - Primitive values (string/number IDs)\n   * - Object references with ID properties\n   * - Arrays of either primitive IDs or object references\n   *\n   * @param result - The result object being transformed\n   * @param originalKey - The original field key from BetterAuth schema\n   * @param fieldName - The renamed field as used in Payload CMS\n   * @param value - The ID value to normalize (primitive, object, or array)\n   */\n  function normalizeDocumentIds(\n    result: Record<string, any>,\n    originalKey: string,\n    fieldName: string,\n    value: any\n  ): void {\n    // Case 1: Primitive ID value (string or number)\n    if (typeof value === \"string\" || typeof value === \"number\") {\n      // For BetterAuth: Always use string IDs\n      result[originalKey] = String(value);\n      // For Payload: Keep original type\n      result[fieldName] = value;\n      return;\n    }\n\n    // Case 2: Object with ID property\n    if (\n      typeof value === \"object\" &&\n      value !== null &&\n      !Array.isArray(value) &&\n      \"id\" in value\n    ) {\n      // For BetterAuth: Extract and stringify the ID\n      result[originalKey] = String(value.id);\n      // Preserve the populated relationship object so joins return full documents\n      result[fieldName] = {\n        ...value,\n        id: String(value.id)\n      };\n      return;\n    }\n\n    // Case 3: Array of IDs or references\n    if (Array.isArray(value) && value.length > 0) {\n      // Check if array contains objects with ID properties\n      if (\n        value.every(\n          (item) => typeof item === \"object\" && item !== null && \"id\" in item\n        )\n      ) {\n        // Array of objects with IDs\n        result[originalKey] = value.map((item) => String(item.id));\n        // Keep joined documents intact while normalizing ID type\n        result[fieldName] = value.map((item) => ({\n          ...item,\n          id: String(item.id)\n        }));\n      } else {\n        // Array of primitive IDs\n        result[originalKey] = value.map((item) => String(item));\n        result[fieldName] = value.map((item) => item);\n      }\n      return;\n    }\n\n    // Note: If value doesn't match any expected format, no changes are made\n  }\n\n  /**\n   * Converts a BetterAuth operator to the equivalent Payload CMS query operator\n   *\n   * This function maps standard query operators from BetterAuth's format to\n   * the specific format expected by Payload CMS's query engine.\n   *\n   * @param operator - The BetterAuth operator string (e.g., 'eq', 'gt', 'contains')\n   * @param value - The value to be used with the operator\n   * @returns An object with the Payload-compatible operator and value\n   *\n   * @example\n   * // Returns { equals: 'test@example.com' }\n   * operatorToPayload('eq', 'test@example.com')\n   *\n   * @example\n   * // Returns { greater_than: 100 }\n   * operatorToPayload('gt', 100)\n   */\n  function operatorToPayload(\n    operator: string,\n    value: any\n  ): Record<string, any> {\n    switch (operator) {\n      case \"eq\":\n        return { equals: value };\n      case \"ne\":\n        return { not_equals: value };\n      case \"gt\":\n        return { greater_than: value };\n      case \"gte\":\n        return { greater_than_equal: value };\n      case \"lt\":\n        return { less_than: value };\n      case \"lte\":\n        return { less_than_equal: value };\n      case \"contains\":\n        return { contains: value };\n      case \"in\":\n        return { in: value };\n      case \"starts_with\":\n        return { like: `${value}%` };\n      case \"ends_with\":\n        return { like: `%${value}` };\n      default:\n        // Fall back to equals for unrecognized operators\n        return { equals: value };\n    }\n  }\n\n  /**\n   * Converts a where clause value to the appropriate type based on field name and ID type configuration\n   *\n   * This function handles two main scenarios:\n   * 1. ID field conversion - ensures IDs match the database's expected type (number or string)\n   * 2. Object with embedded ID - extracts and converts the ID property from objects\n   *\n   * @param value - The value to convert (can be primitive, object with ID, or array)\n   * @param fieldName - The name of the field being queried\n   * @param idType - The expected ID type in the database\n   * @returns The converted value appropriate for the database query\n   */\n  function convertWhereValue({\n    value,\n    fieldName,\n    idType\n  }: {\n    value: any;\n    fieldName: string;\n    idType: \"number\" | \"text\";\n  }) {\n    // Check if field is an ID field (supporting both MongoDB-style _id and standard id)\n    if ([\"id\", \"_id\"].includes(fieldName)) {\n      // Case 1: Value is an object containing an ID property\n      if (typeof value === \"object\" && value !== null && \"id\" in value) {\n        // Extract ID from object\n        const id = value.id;\n\n        // Use type conversion based on database configuration\n        if (idType === \"number\" && typeof id === \"string\") {\n          const numId = Number(id);\n          return !isNaN(numId) ? numId : id;\n        }\n\n        if (idType === \"text\" && typeof id === \"number\") {\n          return String(id);\n        }\n\n        return id;\n      }\n      // Case 2: Value is a standalone ID that needs type conversion\n      // Convert string ID to number if database expects numeric IDs\n      if (\n        idType === \"number\" &&\n        typeof value === \"string\" &&\n        !isNaN(Number(value))\n      ) {\n        return Number(value);\n      }\n      // Convert numeric ID to string if database expects text IDs\n      else if (idType === \"text\" && typeof value === \"number\") {\n        return String(value);\n      }\n      return value;\n    }\n\n    // For non-ID fields, return the value unchanged\n    return value;\n  }\n\n  /**\n   * Converts Better Auth where clauses to Payload CMS compatible where conditions\n   *\n   * This function transforms the Better Auth query format into Payload's query format,\n   * handling field name mapping, value type conversion, and logical operators (AND/OR).\n   *\n   * The function handles three main cases:\n   * 1. Empty or undefined where clause - returns empty object\n   * 2. Single condition - converts to a simple field-value pair\n   * 3. Multiple conditions - groups by AND/OR connectors and builds a complex query\n   *\n   * @param idType - The database ID type ('number' or 'text')\n   * @param model - The model/collection name to query\n   * @param where - Array of Better Auth where conditions\n   * @returns A Payload-compatible where clause object\n   */\n  function convertWhereClause({\n    idType,\n    model,\n    where,\n    payload\n  }: {\n    idType: \"number\" | \"text\";\n    model: ModelKey;\n    where?: Where[];\n    payload: BasePayload;\n  }): PayloadWhere {\n    // Handle empty where clause\n    if (!where) return {};\n\n    function getPayloadFieldName(fieldKey: string): string {\n      return getCollectionFieldNameByFieldKeyUntyped(\n        getCollectionByModelKey(payload.collections, model),\n        fieldKey\n      );\n    }\n\n    // Handle single condition case for optimization\n    if (where.length === 1) {\n      const w = where[0];\n      if (!w) {\n        return {};\n      }\n\n      // Map field name according to schema and convert value to appropriate type\n      const fieldName = getFieldName(model, w.field);\n      const value = convertWhereValue({\n        value: w.value,\n        fieldName,\n        idType\n      });\n\n      // Create the Payload where condition with proper operator\n      const res = {\n        [getPayloadFieldName(fieldName)]: operatorToPayload(\n          w.operator ?? \"\",\n          value\n        )\n      };\n\n      return res;\n    }\n\n    // Handle multiple conditions by separating AND/OR clauses\n    // Default to AND if no connector is specified\n    const and = where.filter((w) => w.connector === \"AND\" || !w.connector);\n    const or = where.filter((w) => w.connector === \"OR\");\n\n    // Process AND conditions\n    const andClause = and.map((w) => {\n      const fieldName = getFieldName(model, w.field);\n      const value = convertWhereValue({\n        value: w.value,\n        fieldName,\n        idType\n      });\n      return {\n        [getPayloadFieldName(fieldName)]: operatorToPayload(\n          w.operator ?? \"\",\n          value\n        )\n      };\n    });\n\n    // Process OR conditions\n    const orClause = or.map((w) => {\n      const fieldName = getFieldName(model, w.field);\n      const value = convertWhereValue({\n        value: w.value,\n        fieldName,\n        idType\n      });\n      return {\n        [getPayloadFieldName(fieldName)]: operatorToPayload(\n          w.operator ?? \"\",\n          value\n        )\n      };\n    });\n\n    // Combine AND and OR clauses into final Payload where object\n    // Only include non-empty clause arrays\n    return {\n      ...(andClause.length ? { AND: andClause } : {}),\n      ...(orClause.length ? { OR: orClause } : {})\n    };\n  }\n\n  /**\n   * Converts a better-auth select array to a Payload select object\n   *\n   * This function transforms the better-auth select array (which contains field names)\n   * into the format expected by Payload CMS's query API (an object with field names as keys\n   * and boolean true as values).\n   *\n   * It also handles field name mapping between better-auth schema and Payload collections\n   * by using the getFieldName helper to resolve the correct field names.\n   *\n   * @param model - The model/collection name to get field mappings from\n   * @param select - Optional array of field names to select\n   * @returns A Payload-compatible select object or undefined if no fields to select\n   * @example\n   * // Input: ['email', 'name']\n   * // Output: { email: true, name: true }\n   */\n  function convertSelect(model: ModelKey, select?: string[]) {\n    // Return undefined if select is empty or not provided\n    if (!select || select.length === 0) return undefined;\n\n    // Transform the array of field names into a Payload select object\n    // while also mapping any field names that might be different in Payload\n    return select.reduce(\n      (acc, field) => ({ ...acc, [getFieldName(model, field)]: true }),\n      {}\n    );\n  }\n\n  /**\n   * Converts a better-auth sort object to a Payload sort string\n   *\n   * This function transforms the better-auth sort object (which contains field name and direction)\n   * into the format expected by Payload CMS's query API (a string with optional '-' prefix for descending order).\n   *\n   * It also handles field name mapping between better-auth schema and Payload collections\n   * by using the getFieldName helper to resolve the correct field names.\n   *\n   * @param model - The model/collection name to get field mappings from\n   * @param sortBy - Optional object containing field name and sort direction\n   * @returns A Payload-compatible sort string or undefined if no sort specified\n   * @example\n   * // Input: { field: 'email', direction: 'desc' }\n   * // Output: '-email'\n   * // Input: { field: 'createdAt', direction: 'asc' }\n   * // Output: 'createdAt'\n   */\n  function convertSort(\n    model: ModelKey,\n    sortBy?: { field: string; direction: \"asc\" | \"desc\" }\n  ): string | undefined {\n    if (!sortBy) return undefined;\n    const fieldName = getFieldName(model, sortBy.field);\n    const prefix = sortBy.direction === \"desc\" ? \"-\" : \"\";\n    return `${prefix}${fieldName}`;\n  }\n\n  return {\n    getFieldName,\n    getCollectionSlug,\n    singleIdQuery,\n    transformInput,\n    transformOutput,\n    convertWhereClause,\n    convertSelect,\n    convertSort\n  };\n};\n"],"names":["getAuthTables","flattenAllFields","getCollectionByModelKey","getCollectionFieldNameByFieldKeyUntyped","getFieldKeyByCollectionFieldName","createTransform","options","enableDebugLogs","schema","debugLog","message","console","log","getCollectionSlug","model","collection","modelName","resolvedSlug","isPayloadRelationship","payload","collectionSlug","fieldName","collections","fields","config","field","find","f","name","type","getFieldName","includes","fieldDefinition","originalField","isRelationshipField","fieldKey","schemaFields","references","undefined","singleIdQuery","where","some","idField","condition","Array","isArray","value","equals","contains","length","normalizeData","key","isRelatedField","idType","parsed","parseInt","isNaN","original","converted","stringId","String","map","id","split","role","trim","toLowerCase","transformInput","data","transformedData","Object","entries","forEach","schemaFieldName","targetFieldName","isPayloadRel","normalizedData","targetFieldKey","isJoinResult","docs","flattenJoinResult","joinResult","item","transformOutput","doc","result","relationshipFields","fromEntries","filter","dateFields","_","keys","originalRelatedFieldKey","k","normalizeDocumentIds","originalDateFieldKey","Date","originalKey","every","operatorToPayload","operator","not_equals","greater_than","greater_than_equal","less_than","less_than_equal","in","like","convertWhereValue","numId","Number","convertWhereClause","getPayloadFieldName","w","res","and","connector","or","andClause","orClause","AND","OR","convertSelect","select","reduce","acc","convertSort","sortBy","prefix","direction"],"mappings":"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"}