payload-auth 1.4.0 → 1.4.1

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

@@ -1,4 +1,3 @@
-import { BetterAuthError } from "better-auth";
 import { getAuthTables } from "better-auth/db";
 export const createTransform = (options, enableDebugLogs)=>{
     const schema = getAuthTables(options);
@@ -7,19 +6,82 @@ export const createTransform = (options, enableDebugLogs)=>{
             console.log(`[payload-db-adapter]`, ...message);
         }
     }
-    function getModelName(model) {
+    /**
+   * 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;
-        if (!collection) {
-            throw new BetterAuthError(`Model ${model} does not exist in the database.`);
-        }
+        debugLog([
+            'getCollectionSlug:',
+            {
+                model,
+                resolvedSlug: collection
+            }
+        ]);
         return collection;
     }
-    function getFieldName(model, field) {
-        if (field === 'id') {
+    /**
+   * 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;
         }
-        const f = schema[model]?.fields[field];
-        const fieldName = f?.fieldName || 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: ',
             {
@@ -30,372 +92,350 @@ export const createTransform = (options, enableDebugLogs)=>{
         ]);
         return fieldName;
     }
-    function isRelationshipField(fieldKey) {
-        return fieldKey.endsWith('Id') || fieldKey.endsWith('By');
+    /**
+   * 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;
     }
-    function isDateField({ key, value }) {
-        if (key) {
-            return (key.endsWith('At') || key.endsWith('Date') || key === 'date') && typeof value === 'string' && !isNaN(Date.parse(value));
-        } else {
-            return typeof value === 'string' && !isNaN(Date.parse(value));
-        }
+    /**
+   * Determines if a value is a valid date string that can be parsed into a Date object.
+   *
+   * This utility function checks if a value is a string and can be successfully parsed
+   * into a JavaScript Date object using Date.parse(). It's used to identify date fields
+   * during data transformation processes.
+   *
+   * @param value - The value to check if it's a valid date string
+   * @returns True if the value is a string that can be parsed as a date, false otherwise
+   *
+   * @example
+   * // Returns true for ISO date strings
+   * isDateField('2023-01-01T12:00:00Z') // true
+   *
+   * @example
+   * // Returns false for non-date strings or other types
+   * isDateField('not a date') // false
+   * isDateField(123) // false
+   */ function isDateField(value) {
+        // Check if value is a string and can be parsed as a valid date
+        return typeof value === 'string' && !isNaN(Date.parse(value));
     }
-    function singleIdQuery(where) {
+    /**
+   * 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;
-        // For a single id query like { id: { equals: 15 } }
-        // First, check if there's an id field in the where clause
-        if ('id' in where || '_id' in where) {
+        // 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];
-            // Check if condition is an object with equals operator
+            // 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;
                 }
             }
-            // Check for contains operator with single 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;
     }
-    function multipleIdsQuery(where) {
-        if (!where || 'and' in where || 'or' in where) return null;
-        if ('id' in where || '_id' in where) {
-            const idField = 'id' in where ? 'id' : '_id';
-            const condition = where[idField];
-            // Check if this is an 'in' operator with id field and array of values
-            if (condition && typeof condition === 'object' && !Array.isArray(condition) && 'in' in condition && Array.isArray(condition.in) && condition.in.length > 1 && condition.in.every((id)=>typeof id === 'string' || typeof id === 'number')) {
-                return condition.in;
-            }
-            // Also check for contains operator with array of IDs
-            if (condition && typeof condition === 'object' && !Array.isArray(condition) && 'contains' in condition && Array.isArray(condition.contains) && condition.contains.length > 1 && condition.contains.every((id)=>typeof id === 'string' || typeof id === 'number')) {
-                return condition.contains;
-            }
-        }
-        return null;
-    }
-    function normalizeData({ fieldKey, incomingValue, schemaFields, relationshipField, idType }) {
-        // Early return for null/undefined values
-        if (incomingValue === null || incomingValue === undefined) {
-            return incomingValue;
-        }
-        //special case for accountId field in accounts collection
-        if (fieldKey === 'accountId') {
-            return String(incomingValue);
+    /**
+   * 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;
         }
-        // Handle relationship fields (IDs) based on idType
-        if (relationshipField) {
-            if (idType === 'number' && typeof incomingValue === 'string') {
-                const parsed = parseInt(incomingValue, 10);
+        if ([
+            'id',
+            '_id'
+        ].includes(key)) {
+            if (typeof value === 'string' && idType === 'number') {
+                const parsed = parseInt(value, 10);
                 if (!isNaN(parsed)) {
                     debugLog([
-                        `ID conversion: ${fieldKey} converting string ID to number`,
+                        `ID conversion: ${key} converting string ID to number`,
                         {
-                            original: incomingValue,
+                            original: value,
                             converted: parsed
                         }
                     ]);
                     return parsed;
                 }
-            } else if (idType === 'text' && typeof incomingValue === 'number') {
-                const stringId = String(incomingValue);
+            }
+            if (typeof value === 'number' && idType === 'text') {
+                const stringId = String(value);
                 debugLog([
-                    `ID conversion: ${fieldKey} converting number ID to string`,
+                    `ID conversion: ${key} converting number ID to string`,
                     {
-                        original: incomingValue,
+                        original: value,
                         converted: stringId
                     }
                 ]);
                 return stringId;
             }
-            // Handle array of IDs
-            if (Array.isArray(incomingValue)) {
-                return incomingValue.map((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;
-                });
-            }
-            return incomingValue;
         }
-        const schemaField = schemaFields[fieldKey];
-        // If no schema field exists, return as is
-        if (!schemaField) {
-            return incomingValue;
-        }
-        const fieldType = schemaField.type;
-        // Handle string type
-        if (fieldType === 'string') {
-            if (typeof incomingValue !== 'string') {
-                if (incomingValue instanceof Date) {
-                    const converted = incomingValue.toISOString();
-                    debugLog([
-                        `Type conversion: ${fieldKey} expected string but got Date`,
-                        {
-                            original: incomingValue,
-                            converted
-                        }
-                    ]);
-                    return converted;
-                }
-                const converted = String(incomingValue);
-                debugLog([
-                    `Type conversion: ${fieldKey} expected string but got ${typeof incomingValue}`,
-                    {
-                        original: incomingValue,
-                        converted
-                    }
-                ]);
-                return converted;
-            }
-            return incomingValue;
-        }
-        // Handle number type
-        if (fieldType === 'number') {
-            if (typeof incomingValue !== 'number') {
-                if (incomingValue instanceof Date) {
-                    const converted = incomingValue.getTime();
-                    debugLog([
-                        `Type conversion: ${fieldKey} expected number but got Date`,
-                        {
-                            original: incomingValue,
-                            converted
-                        }
-                    ]);
-                    return converted;
-                }
-                if (typeof incomingValue === 'boolean') {
-                    const converted = incomingValue ? 1 : 0;
+        // 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([
-                        `Type conversion: ${fieldKey} expected number but got boolean`,
+                        `ID conversion: ${key} converting string ID to number`,
                         {
-                            original: incomingValue,
-                            converted
+                            original: value,
+                            converted: parsed
                         }
                     ]);
-                    return converted;
-                }
-                if (typeof incomingValue === 'string') {
-                    const parsed = parseFloat(incomingValue);
-                    if (!isNaN(parsed)) {
-                        debugLog([
-                            `Type conversion: ${fieldKey} expected number but got string`,
-                            {
-                                original: incomingValue,
-                                converted: parsed
-                            }
-                        ]);
-                        return parsed;
-                    }
-                }
-            }
-            return incomingValue;
-        }
-        // Handle boolean type
-        if (fieldType === 'boolean') {
-            if (typeof incomingValue !== 'boolean') {
-                let converted;
-                if (typeof incomingValue === 'string') {
-                    converted = incomingValue.toLowerCase() === 'true' || incomingValue === '1';
-                } else if (typeof incomingValue === 'number') {
-                    converted = incomingValue !== 0;
-                } else {
-                    converted = !!incomingValue;
+                    return parsed;
                 }
+            } else if (typeof value === 'number' && idType === 'text') {
+                const stringId = String(value);
                 debugLog([
-                    `Type conversion: ${fieldKey} expected boolean but got ${typeof incomingValue}`,
+                    `ID conversion: ${key} converting number ID to string`,
                     {
-                        original: incomingValue,
-                        converted
+                        original: value,
+                        converted: stringId
                     }
                 ]);
-                return converted;
+                return stringId;
             }
-            return incomingValue;
-        }
-        // Handle date type
-        if (fieldType === 'date') {
-            if (!(incomingValue instanceof Date)) {
-                let converted;
-                if (typeof incomingValue === 'string' || typeof incomingValue === 'number') {
-                    converted = new Date(incomingValue);
-                    if (!isNaN(converted.getTime())) {
-                        debugLog([
-                            `Type conversion: ${fieldKey} expected Date but got ${typeof incomingValue}`,
-                            {
-                                original: incomingValue,
-                                converted
-                            }
-                        ]);
-                        return converted;
+            // 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;
+                });
             }
-            return incomingValue;
         }
-        // Handle array types (string[] or number[] or LiteralString[])
-        if (typeof fieldType === 'string' && fieldType.endsWith('[]')) {
-            const baseType = fieldType.slice(0, -2);
-            // Convert to array if not already
-            let arrayValue = incomingValue;
-            if (!Array.isArray(incomingValue)) {
-                if (typeof incomingValue === 'string') {
-                    try {
-                        // Try to parse as JSON array
-                        const parsed = JSON.parse(incomingValue);
-                        if (Array.isArray(parsed)) {
-                            debugLog([
-                                `Type conversion: ${fieldKey} parsed JSON string to array`,
-                                {
-                                    original: incomingValue,
-                                    converted: parsed
-                                }
-                            ]);
-                            arrayValue = parsed;
-                        } else {
-                            arrayValue = [
-                                incomingValue
-                            ];
-                        }
-                    } catch (e) {
-                        // If parsing fails, wrap in array
-                        arrayValue = [
-                            incomingValue
-                        ];
-                    }
-                } else {
-                    // Wrap non-array values in array
-                    arrayValue = [
-                        incomingValue
-                    ];
-                }
-                debugLog([
-                    `Type conversion: ${fieldKey} converted to array`,
-                    {
-                        original: incomingValue,
-                        converted: arrayValue
-                    }
-                ]);
-            }
-            // Normalize each array element based on the base type
-            return arrayValue.map((item, index)=>{
-                if (baseType === 'string' && typeof item !== 'string') {
-                    const converted = String(item);
-                    debugLog([
-                        `Type conversion: ${fieldKey}[${index}] expected string but got ${typeof item}`,
-                        {
-                            original: item,
-                            converted
-                        }
-                    ]);
-                    return converted;
-                }
-                if (baseType === 'number' && typeof item !== 'number') {
-                    if (typeof item === 'string') {
-                        const parsed = parseFloat(item);
-                        if (!isNaN(parsed)) {
-                            debugLog([
-                                `Type conversion: ${fieldKey}[${index}] expected number but got string`,
-                                {
-                                    original: item,
-                                    converted: parsed
-                                }
-                            ]);
-                            return parsed;
-                        }
-                    } else if (typeof item === 'boolean') {
-                        return item ? 1 : 0;
-                    }
-                }
-                return item;
-            });
-        }
-        // For any other types or if no conversion needed, return as is
-        return incomingValue;
+        // Return original value if no conversion was needed or applicable
+        return value;
     }
-    function transformInput({ data, model, idType, action }) {
+    /**
+   * 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 }) {
         const transformedData = {};
         const schemaFields = schema[model].fields;
-        for(const fieldKey in data){
-            if (data[fieldKey] === undefined && action === 'update') {
-                continue;
+        // Process each field in the input data
+        Object.entries(data).forEach(([key, value])=>{
+            // Skip null/undefined values
+            if (value === null || value === undefined) {
+                return;
             }
-            const relationshipField = isRelationshipField(fieldKey);
-            const schemaFieldName = schemaFields[fieldKey]?.fieldName;
+            // Determine if this is a relationship field
+            const isRelatedField = isRelationshipField(key, schemaFields);
+            // Get the mapped field name from schema (if any)
+            const schemaFieldName = schemaFields[key]?.fieldName;
+            // Normalize the data value based on field type and ID type
             const normalizedData = normalizeData({
                 idType,
-                fieldKey,
-                incomingValue: data[fieldKey],
-                schemaFields,
-                relationshipField
+                key,
+                value,
+                isRelatedField
             });
-            if (schemaFieldName) {
-                transformedData[schemaFieldName] = normalizedData;
-            } else {
-                transformedData[fieldKey] = normalizedData;
-            }
-        }
+            // Use the schema-defined field name if available, otherwise use original key
+            const targetFieldName = schemaFieldName || key;
+            transformedData[targetFieldName] = normalizedData;
+        });
         return transformedData;
     }
-    function transformOutput({ doc, model }) {
-        if (doc === null || doc === undefined || typeof doc !== 'object') return doc;
+    /**
+   * 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
+   *
+   * 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 }) {
+        if (!doc || typeof doc !== 'object') return doc;
         const result = {
             ...doc
         };
         const schemaFields = schema[model].fields;
-        const relationshipFields = Object.entries(schemaFields).filter(([key])=>isRelationshipField(key)).reduce((acc, [key, value])=>({
-                ...acc,
-                [key]: value
-            }), {});
+        // Identify relationship fields with custom field name mappings
+        const relationshipFields = Object.fromEntries(Object.entries(schemaFields).filter(([key])=>isRelationshipField(key, schemaFields)));
         Object.entries(doc).forEach(([key, value])=>{
             if (value === null || value === undefined) return;
-            const originalKey = findRelationshipOriginalKey(key, relationshipFields);
-            if (originalKey) {
-                processRelationshipField(result, originalKey, key, value);
+            // Convert ID fields to strings for BetterAuth compatibility
+            if ([
+                'id',
+                '_id'
+            ].includes(key)) {
+                result[key] = String(value);
+                return;
             }
-            if (isDateField({
-                key,
-                value
-            })) {
+            // 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;
+            }
+            // Convert ISO date strings to Date objects for BetterAuth
+            if (isDateField(value)) {
                 result[key] = new Date(value);
+                return;
             }
         });
         return result;
     }
-    function findRelationshipOriginalKey(fieldName, relationshipFields) {
-        return Object.keys(relationshipFields).find((key)=>relationshipFields[key].fieldName === fieldName);
-    }
-    function processRelationshipField(result, originalKey, fieldName, value) {
-        // Simple ID value (string or number)
+    /**
+   * 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') {
-            result[originalKey] = value;
+            // 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 && 'id' in value) {
+            // For BetterAuth: Extract and stringify the ID
+            result[originalKey] = String(value.id);
+            // For Payload: Extract ID but preserve type
+            result[fieldName] = value.id;
             return;
         }
-        // Array of relationships
+        // Case 3: Array of IDs or references
         if (Array.isArray(value) && value.length > 0) {
-            if (value.every((item)=>typeof item === 'object' && 'id' in item)) {
-                result[originalKey] = value.map((item)=>item.id);
+            // 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));
                 result[fieldName] = value.map((item)=>item.id);
+            } else {
+                // Array of primitive IDs
+                result[originalKey] = value.map((item)=>String(item));
+                result[fieldName] = value.map((item)=>item);
             }
             return;
         }
-        // Single relationship object with ID
-        if (typeof value === 'object' && 'id' in value) {
-            result[originalKey] = value.id;
-            result[fieldName] = value.id;
-        }
+    // Note: If value doesn't match any expected format, no changes are made
     }
-    function operatorToPayload(operator, value) {
+    /**
+   * 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 {
@@ -438,24 +478,45 @@ export const createTransform = (options, enableDebugLogs)=>{
                     like: `%${value}`
                 };
             default:
+                // Fall back to equals for unrecognized operators
                 return {
                     equals: value
                 };
         }
     }
-    function convertWhereValue({ value, fieldName, idType }) {
-        if (fieldName === 'id' || fieldName === '_id') {
+    /**
+   * 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 and ensure it matches the expected type
+                // Extract ID from object
                 const id = value.id;
-                if (idType === 'number' && typeof id === 'string' && !isNaN(Number(id))) {
-                    return Number(id);
-                } else if (idType === 'text' && typeof id === 'number') {
+                // 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;
             }
-            // Convert standalone ID value to match expected type
+            // 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') {
@@ -463,28 +524,51 @@ export const createTransform = (options, enableDebugLogs)=>{
             }
             return value;
         }
+        // For non-ID fields, return the value unchanged
         return value;
     }
-    function convertWhereClause({ idType, model, where }) {
+    /**
+   * 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 }) {
+        // Handle empty where clause
         if (!where) return {};
+        // 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 = {
                 [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({
@@ -496,6 +580,7 @@ export const createTransform = (options, enableDebugLogs)=>{
                 [fieldName]: operatorToPayload(w.operator ?? '', value)
             };
         });
+        // Process OR conditions
         const orClause = or.map((w)=>{
             const fieldName = getFieldName(model, w.field);
             const value = convertWhereValue({
@@ -507,6 +592,8 @@ export const createTransform = (options, enableDebugLogs)=>{
                 [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
@@ -516,22 +603,59 @@ export const createTransform = (options, enableDebugLogs)=>{
             } : {}
         };
     }
-    function convertSelect(model, select) {
+    /**
+   * 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
             }), {});
     }
-    function convertSort(model, sortBy) {
+    /**
+   * 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;
-        return `${sortBy.direction === 'desc' ? '-' : ''}${getFieldName(model, sortBy.field)}`;
+        const fieldName = getFieldName(model, sortBy.field);
+        const prefix = sortBy.direction === 'desc' ? '-' : '';
+        return `${prefix}${fieldName}`;
     }
     return {
         getFieldName,
-        getModelName,
+        getCollectionSlug,
         singleIdQuery,
-        multipleIdsQuery,
         transformInput,
         transformOutput,
         convertWhereClause,
@@ -540,4 +664,4 @@ export const createTransform = (options, enableDebugLogs)=>{
     };
 };
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/better-auth/adapter/transform/index.ts"],"sourcesContent":["import { BetterAuthError } from 'better-auth'\nimport { FieldAttribute, FieldType, getAuthTables } from 'better-auth/db'\nimport type { BetterAuthOptions, Where } from 'better-auth'\nimport type { CollectionSlug, Where as PayloadWhere } from 'payload'\n\nexport const createTransform = (options: BetterAuthOptions, enableDebugLogs: boolean) => {\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  function getModelName(model: string): CollectionSlug {\n    const collection = (schema as Record<string, any>)[model]?.modelName || model\n    if (!collection) {\n      throw new BetterAuthError(`Model ${model} does not exist in the database.`)\n    }\n    return collection as CollectionSlug\n  }\n\n  function getFieldName(model: string, field: string) {\n    if (field === 'id') {\n      return field\n    }\n    const f = schema[model]?.fields[field]\n    const fieldName = f?.fieldName || field\n    debugLog(['getField: ', { model, originalField: field, fieldName }])\n    return fieldName\n  }\n\n  function isRelationshipField(fieldKey: string) {\n    return fieldKey.endsWith('Id') || fieldKey.endsWith('By')\n  }\n\n  function isDateField({ key, value }: { key?: string; value: any }) {\n    if (key) {\n      return (key.endsWith('At') || key.endsWith('Date') || key === 'date') && typeof value === 'string' && !isNaN(Date.parse(value))\n    } else {\n      return typeof value === 'string' && !isNaN(Date.parse(value))\n    }\n  }\n\n  function singleIdQuery(where: PayloadWhere) {\n    if (!where || 'and' in where || 'or' in where) return null\n\n    // For a single id query like { id: { equals: 15 } }\n    // First, check if there's an id field in the where clause\n    if ('id' in where || '_id' in where) {\n      const idField = 'id' in where ? 'id' : '_id'\n      const condition = where[idField]\n\n      // Check if condition is an object with equals operator\n      if (condition && typeof condition === 'object' && !Array.isArray(condition) && 'equals' in condition) {\n        const value = condition.equals\n        if (typeof value === 'string' || typeof value === 'number') {\n          return value\n        }\n      }\n\n      // Check for contains operator with 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        if (typeof value === 'string' || typeof value === 'number') {\n          return value\n        }\n      }\n    }\n\n    return null\n  }\n\n  function multipleIdsQuery(where: PayloadWhere) {\n    if (!where || 'and' in where || 'or' in where) return null\n    if ('id' in where || '_id' in where) {\n      const idField = 'id' in where ? 'id' : '_id'\n      const condition = where[idField]\n\n      // Check if this is an 'in' operator with id field and array of values\n      if (\n        condition &&\n        typeof condition === 'object' &&\n        !Array.isArray(condition) &&\n        'in' in condition &&\n        Array.isArray(condition.in) &&\n        condition.in.length > 1 &&\n        condition.in.every((id: unknown) => typeof id === 'string' || typeof id === 'number')\n      ) {\n        return condition.in as (number | string)[]\n      }\n\n      // Also check for contains operator with array of IDs\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        condition.contains.every((id: unknown) => typeof id === 'string' || typeof id === 'number')\n      ) {\n        return condition.contains as (number | string)[]\n      }\n    }\n    return null\n  }\n\n  function normalizeData({\n    fieldKey,\n    incomingValue,\n    schemaFields,\n    relationshipField,\n    idType\n  }: {\n    fieldKey: string\n    incomingValue: any\n    schemaFields: Record<string, FieldAttribute<FieldType>>\n    relationshipField: boolean\n    idType: 'number' | 'text'\n  }) {\n    // Early return for null/undefined values\n    if (incomingValue === null || incomingValue === undefined) {\n      return incomingValue\n    }\n\n    //special case for accountId field in accounts collection\n    if (fieldKey === 'accountId') {\n      return String(incomingValue)\n    }\n\n    // Handle relationship fields (IDs) based on idType\n    if (relationshipField) {\n      if (idType === 'number' && typeof incomingValue === 'string') {\n        const parsed = parseInt(incomingValue, 10)\n        if (!isNaN(parsed)) {\n          debugLog([`ID conversion: ${fieldKey} converting string ID to number`, { original: incomingValue, converted: parsed }])\n          return parsed\n        }\n      } else if (idType === 'text' && typeof incomingValue === 'number') {\n        const stringId = String(incomingValue)\n        debugLog([`ID conversion: ${fieldKey} converting number ID to string`, { original: incomingValue, converted: stringId }])\n        return stringId\n      }\n\n      // Handle array of IDs\n      if (Array.isArray(incomingValue)) {\n        return incomingValue.map((id) => {\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      return incomingValue\n    }\n\n    const schemaField = schemaFields[fieldKey]\n\n    // If no schema field exists, return as is\n    if (!schemaField) {\n      return incomingValue\n    }\n\n    const fieldType = schemaField.type\n\n    // Handle string type\n    if (fieldType === 'string') {\n      if (typeof incomingValue !== 'string') {\n        if (incomingValue instanceof Date) {\n          const converted = incomingValue.toISOString()\n          debugLog([`Type conversion: ${fieldKey} expected string but got Date`, { original: incomingValue, converted }])\n          return converted\n        }\n\n        const converted = String(incomingValue)\n        debugLog([`Type conversion: ${fieldKey} expected string but got ${typeof incomingValue}`, { original: incomingValue, converted }])\n        return converted\n      }\n      return incomingValue\n    }\n\n    // Handle number type\n    if (fieldType === 'number') {\n      if (typeof incomingValue !== 'number') {\n        if (incomingValue instanceof Date) {\n          const converted = incomingValue.getTime()\n          debugLog([`Type conversion: ${fieldKey} expected number but got Date`, { original: incomingValue, converted }])\n          return converted\n        }\n\n        if (typeof incomingValue === 'boolean') {\n          const converted = incomingValue ? 1 : 0\n          debugLog([`Type conversion: ${fieldKey} expected number but got boolean`, { original: incomingValue, converted }])\n          return converted\n        }\n\n        if (typeof incomingValue === 'string') {\n          const parsed = parseFloat(incomingValue)\n          if (!isNaN(parsed)) {\n            debugLog([`Type conversion: ${fieldKey} expected number but got string`, { original: incomingValue, converted: parsed }])\n            return parsed\n          }\n        }\n      }\n      return incomingValue\n    }\n\n    // Handle boolean type\n    if (fieldType === 'boolean') {\n      if (typeof incomingValue !== 'boolean') {\n        let converted\n\n        if (typeof incomingValue === 'string') {\n          converted = incomingValue.toLowerCase() === 'true' || incomingValue === '1'\n        } else if (typeof incomingValue === 'number') {\n          converted = incomingValue !== 0\n        } else {\n          converted = !!incomingValue\n        }\n\n        debugLog([`Type conversion: ${fieldKey} expected boolean but got ${typeof incomingValue}`, { original: incomingValue, converted }])\n        return converted\n      }\n      return incomingValue\n    }\n\n    // Handle date type\n    if (fieldType === 'date') {\n      if (!(incomingValue instanceof Date)) {\n        let converted\n\n        if (typeof incomingValue === 'string' || typeof incomingValue === 'number') {\n          converted = new Date(incomingValue)\n          if (!isNaN(converted.getTime())) {\n            debugLog([`Type conversion: ${fieldKey} expected Date but got ${typeof incomingValue}`, { original: incomingValue, converted }])\n            return converted\n          }\n        }\n      }\n      return incomingValue\n    }\n\n    // Handle array types (string[] or number[] or LiteralString[])\n    if (typeof fieldType === 'string' && fieldType.endsWith('[]')) {\n      const baseType = fieldType.slice(0, -2)\n\n      // Convert to array if not already\n      let arrayValue = incomingValue\n      if (!Array.isArray(incomingValue)) {\n        if (typeof incomingValue === 'string') {\n          try {\n            // Try to parse as JSON array\n            const parsed = JSON.parse(incomingValue)\n            if (Array.isArray(parsed)) {\n              debugLog([`Type conversion: ${fieldKey} parsed JSON string to array`, { original: incomingValue, converted: parsed }])\n              arrayValue = parsed\n            } else {\n              arrayValue = [incomingValue]\n            }\n          } catch (e) {\n            // If parsing fails, wrap in array\n            arrayValue = [incomingValue]\n          }\n        } else {\n          // Wrap non-array values in array\n          arrayValue = [incomingValue]\n        }\n\n        debugLog([`Type conversion: ${fieldKey} converted to array`, { original: incomingValue, converted: arrayValue }])\n      }\n\n      // Normalize each array element based on the base type\n      return arrayValue.map((item: any, index: number) => {\n        if (baseType === 'string' && typeof item !== 'string') {\n          const converted = String(item)\n          debugLog([`Type conversion: ${fieldKey}[${index}] expected string but got ${typeof item}`, { original: item, converted }])\n          return converted\n        }\n\n        if (baseType === 'number' && typeof item !== 'number') {\n          if (typeof item === 'string') {\n            const parsed = parseFloat(item)\n            if (!isNaN(parsed)) {\n              debugLog([`Type conversion: ${fieldKey}[${index}] expected number but got string`, { original: item, converted: parsed }])\n              return parsed\n            }\n          } else if (typeof item === 'boolean') {\n            return item ? 1 : 0\n          }\n        }\n        return item\n      })\n    }\n\n    // For any other types or if no conversion needed, return as is\n    return incomingValue\n  }\n\n  function transformInput({\n    data,\n    model,\n    idType,\n    action\n  }: {\n    data: Record<string, any>\n    model: string\n    idType: 'number' | 'text'\n    action: 'create' | 'update'\n  }) {\n    const transformedData: Record<string, any> = {}\n    const schemaFields = schema[model].fields\n    for (const fieldKey in data) {\n      if (data[fieldKey] === undefined && action === 'update') {\n        continue\n      }\n      const relationshipField = isRelationshipField(fieldKey)\n      const schemaFieldName = schemaFields[fieldKey]?.fieldName\n      const normalizedData = normalizeData({\n        idType,\n        fieldKey,\n        incomingValue: data[fieldKey],\n        schemaFields,\n        relationshipField\n      })\n      if (schemaFieldName) {\n        transformedData[schemaFieldName] = normalizedData\n      } else {\n        transformedData[fieldKey] = normalizedData\n      }\n    }\n\n    return transformedData\n  }\n\n  function transformOutput<T extends Record<string, any> | null>({ doc, model }: { doc: T; model: string }): T {\n    if (doc === null || doc === undefined || typeof doc !== 'object') return doc\n\n    const result = { ...doc } as any\n    const schemaFields = schema[model].fields\n    const relationshipFields = Object.entries(schemaFields)\n      .filter(([key]) => isRelationshipField(key))\n      .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {} as Record<string, FieldAttribute<FieldType>>)\n\n    Object.entries(doc).forEach(([key, value]) => {\n      if (value === null || value === undefined) return\n\n      const originalKey = findRelationshipOriginalKey(key, relationshipFields)\n      if (originalKey) {\n        processRelationshipField(result, originalKey, key, value)\n      }\n\n      if (isDateField({ key, value })) {\n        result[key] = new Date(value)\n      }\n    })\n\n    return result as T\n  }\n\n  function findRelationshipOriginalKey(\n    fieldName: string,\n    relationshipFields: Record<string, FieldAttribute<FieldType>>\n  ): string | undefined {\n    return Object.keys(relationshipFields).find((key) => relationshipFields[key].fieldName === fieldName)\n  }\n\n  function processRelationshipField(result: Record<string, any>, originalKey: string, fieldName: string, value: any): void {\n    // Simple ID value (string or number)\n    if (typeof value === 'string' || typeof value === 'number') {\n      result[originalKey] = value\n      return\n    }\n\n    // Array of relationships\n    if (Array.isArray(value) && value.length > 0) {\n      if (value.every((item) => typeof item === 'object' && 'id' in item)) {\n        result[originalKey] = value.map((item) => item.id)\n        result[fieldName] = value.map((item) => item.id)\n      }\n      return\n    }\n\n    // Single relationship object with ID\n    if (typeof value === 'object' && 'id' in value) {\n      result[originalKey] = value.id\n      result[fieldName] = value.id\n    }\n  }\n\n  function operatorToPayload(operator: string, value: 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        return { equals: value }\n    }\n  }\n\n  function convertWhereValue({ value, fieldName, idType }: { value: any; fieldName: string; idType: 'number' | 'text' }) {\n    if (fieldName === 'id' || fieldName === '_id') {\n      if (typeof value === 'object' && value !== null && 'id' in value) {\n        // Extract ID from object and ensure it matches the expected type\n        const id = value.id\n        if (idType === 'number' && typeof id === 'string' && !isNaN(Number(id))) {\n          return Number(id)\n        } else if (idType === 'text' && typeof id === 'number') {\n          return String(id)\n        }\n        return id\n      }\n      // Convert standalone ID value to match expected type\n      if (idType === 'number' && typeof value === 'string' && !isNaN(Number(value))) {\n        return Number(value)\n      } else if (idType === 'text' && typeof value === 'number') {\n        return String(value)\n      }\n      return value\n    }\n    return value\n  }\n\n  function convertWhereClause({ idType, model, where }: { idType: 'number' | 'text'; model: string; where?: Where[] }): PayloadWhere {\n    if (!where) return {}\n    if (where.length === 1) {\n      const w = where[0]\n      if (!w) {\n        return {}\n      }\n\n      const fieldName = getFieldName(model, w.field)\n      const value = convertWhereValue({\n        value: w.value,\n        fieldName,\n        idType\n      })\n\n      const res = {\n        [fieldName]: operatorToPayload(w.operator ?? '', value)\n      }\n\n      return res\n    }\n    const and = where.filter((w) => w.connector === 'AND' || !w.connector)\n    const or = where.filter((w) => w.connector === 'OR')\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        [fieldName]: operatorToPayload(w.operator ?? '', value)\n      }\n    })\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        [fieldName]: operatorToPayload(w.operator ?? '', value)\n      }\n    })\n\n    return {\n      ...(andClause.length ? { AND: andClause } : {}),\n      ...(orClause.length ? { OR: orClause } : {})\n    }\n  }\n\n  function convertSelect(model: string, select?: string[]) {\n    if (!select || select.length === 0) return undefined\n    return select.reduce((acc, field) => ({ ...acc, [getFieldName(model, field)]: true }), {})\n  }\n\n  function convertSort(model: string, sortBy?: { field: string; direction: 'asc' | 'desc' }) {\n    if (!sortBy) return undefined\n    return `${sortBy.direction === 'desc' ? '-' : ''}${getFieldName(model, sortBy.field)}`\n  }\n\n  return {\n    getFieldName,\n    getModelName,\n    singleIdQuery,\n    multipleIdsQuery,\n    transformInput,\n    transformOutput,\n    convertWhereClause,\n    convertSelect,\n    convertSort\n  }\n}\n"],"names":["BetterAuthError","getAuthTables","createTransform","options","enableDebugLogs","schema","debugLog","message","console","log","getModelName","model","collection","modelName","getFieldName","field","f","fields","fieldName","originalField","isRelationshipField","fieldKey","endsWith","isDateField","key","value","isNaN","Date","parse","singleIdQuery","where","idField","condition","Array","isArray","equals","contains","length","multipleIdsQuery","in","every","id","normalizeData","incomingValue","schemaFields","relationshipField","idType","undefined","String","parsed","parseInt","original","converted","stringId","map","schemaField","fieldType","type","toISOString","getTime","parseFloat","toLowerCase","baseType","slice","arrayValue","JSON","e","item","index","transformInput","data","action","transformedData","schemaFieldName","normalizedData","transformOutput","doc","result","relationshipFields","Object","entries","filter","reduce","acc","forEach","originalKey","findRelationshipOriginalKey","processRelationshipField","keys","find","operatorToPayload","operator","not_equals","greater_than","greater_than_equal","less_than","less_than_equal","like","convertWhereValue","Number","convertWhereClause","w","res","and","connector","or","andClause","orClause","AND","OR","convertSelect","select","convertSort","sortBy","direction"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/better-auth/adapter/transform/index.ts"],"sourcesContent":["import { FieldAttribute, FieldType, getAuthTables } from 'better-auth/db'\nimport type { BetterAuthOptions, Where } from 'better-auth'\nimport type { CollectionSlug, Where as PayloadWhere } from 'payload'\n\nexport const createTransform = (options: BetterAuthOptions, enableDebugLogs: boolean) => {\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: string): 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   * 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: string, 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(fieldKey: string, schemaFields: Record<string, FieldAttribute<FieldType>>): boolean {\n    // A field is a relationship field if it has a 'references' property defined\n    return schemaFields[fieldKey]?.references !== undefined\n  }\n\n  /**\n   * Determines if a value is a valid date string that can be parsed into a Date object.\n   *\n   * This utility function checks if a value is a string and can be successfully parsed\n   * into a JavaScript Date object using Date.parse(). It's used to identify date fields\n   * during data transformation processes.\n   *\n   * @param value - The value to check if it's a valid date string\n   * @returns True if the value is a string that can be parsed as a date, false otherwise\n   *\n   * @example\n   * // Returns true for ISO date strings\n   * isDateField('2023-01-01T12:00:00Z') // true\n   *\n   * @example\n   * // Returns false for non-date strings or other types\n   * isDateField('not a date') // false\n   * isDateField(123) // false\n   */\n  function isDateField(value: any): boolean {\n    // Check if value is a string and can be parsed as a valid date\n    return typeof value === 'string' && !isNaN(Date.parse(value))\n  }\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 (condition && typeof condition === 'object' && !Array.isArray(condition) && 'equals' in condition) {\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([`ID conversion: ${key} converting string ID to number`, { original: value, converted: parsed }])\n          return parsed\n        }\n      }\n      if (typeof value === 'number' && idType === 'text') {\n        const stringId = String(value)\n        debugLog([`ID conversion: ${key} converting number ID to string`, { original: value, converted: stringId }])\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([`ID conversion: ${key} converting string ID to number`, { original: value, converted: parsed }])\n          return parsed\n        }\n      } else if (typeof value === 'number' && idType === 'text') {\n        const stringId = String(value)\n        debugLog([`ID conversion: ${key} converting number ID to string`, { original: value, converted: stringId }])\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    // 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  }: {\n    data: Record<string, any>\n    model: string\n    idType: 'number' | 'text'\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      // Determine if this is a relationship field\n      const isRelatedField = isRelationshipField(key, schemaFields)\n\n      // Get the mapped field name from schema (if any)\n      const schemaFieldName = schemaFields[key]?.fieldName\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      // Use the schema-defined field name if available, otherwise use original key\n      const targetFieldName = schemaFieldName || key\n      transformedData[targetFieldName] = normalizedData\n    })\n\n    return transformedData\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   * 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>({ doc, model }: { doc: T; model: string }): 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(Object.entries(schemaFields).filter(([key]) => isRelationshipField(key, schemaFields)))\n\n    Object.entries(doc).forEach(([key, value]) => {\n      if (value === null || value === undefined) return\n\n      // Convert ID fields to strings for BetterAuth compatibility\n      if (['id', '_id'].includes(key)) {\n        result[key] = String(value)\n        return\n      }\n\n      // Handle relationship fields with renamed fieldNames\n      const originalRelatedFieldKey = Object.keys(relationshipFields).find((k) => relationshipFields[k].fieldName === key)\n      if (originalRelatedFieldKey) {\n        normalizeDocumentIds(result, originalRelatedFieldKey, key, value)\n        return\n      }\n\n      // Convert ISO date strings to Date objects for BetterAuth\n      if (isDateField(value)) {\n        result[key] = 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(result: Record<string, any>, originalKey: string, fieldName: string, value: any): 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 (typeof value === 'object' && value !== null && 'id' in value) {\n      // For BetterAuth: Extract and stringify the ID\n      result[originalKey] = String(value.id)\n      // For Payload: Extract ID but preserve type\n      result[fieldName] = value.id\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 (value.every((item) => typeof item === 'object' && item !== null && 'id' in item)) {\n        // Array of objects with IDs\n        result[originalKey] = value.map((item) => String(item.id))\n        result[fieldName] = value.map((item) => item.id)\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(operator: string, value: any): 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({ value, fieldName, idType }: { value: any; fieldName: string; idType: 'number' | 'text' }) {\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 (idType === 'number' && typeof value === 'string' && !isNaN(Number(value))) {\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({ idType, model, where }: { idType: 'number' | 'text'; model: string; where?: Where[] }): PayloadWhere {\n    // Handle empty where clause\n    if (!where) return {}\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        [fieldName]: operatorToPayload(w.operator ?? '', value)\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        [fieldName]: operatorToPayload(w.operator ?? '', value)\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        [fieldName]: operatorToPayload(w.operator ?? '', value)\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: string, 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((acc, field) => ({ ...acc, [getFieldName(model, field)]: true }), {})\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(model: string, sortBy?: { field: string; direction: 'asc' | 'desc' }): 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","createTransform","options","enableDebugLogs","schema","debugLog","message","console","log","getCollectionSlug","model","collection","modelName","resolvedSlug","getFieldName","field","includes","fieldDefinition","fields","fieldName","originalField","isRelationshipField","fieldKey","schemaFields","references","undefined","isDateField","value","isNaN","Date","parse","singleIdQuery","where","some","idField","condition","Array","isArray","equals","contains","length","normalizeData","key","isRelatedField","idType","parsed","parseInt","original","converted","stringId","String","map","id","transformInput","data","transformedData","Object","entries","forEach","schemaFieldName","normalizedData","targetFieldName","transformOutput","doc","result","relationshipFields","fromEntries","filter","originalRelatedFieldKey","keys","find","k","normalizeDocumentIds","originalKey","every","item","operatorToPayload","operator","not_equals","greater_than","greater_than_equal","less_than","less_than_equal","in","like","convertWhereValue","numId","Number","convertWhereClause","w","res","and","connector","or","andClause","orClause","AND","OR","convertSelect","select","reduce","acc","convertSort","sortBy","prefix","direction"],"mappings":"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"}