@revealui/auth 0.0.1-pre.0

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

@@ -0,0 +1,731 @@
+import { BetterAuthError } from "..";
+import { generateSchema } from "./generate-schema";
+import { createTransform } from "./transform";
+export const BETTER_AUTH_CONTEXT_KEY = 'payload-db-adapter';
+const PAYLOAD_QUERY_DEPTH = 0;
+const DEBUG_LOG_PREFIX = '[payload-db-adapter]';
+/**
+ * Payload adapter for Better Auth
+ *
+ * This adapter connects Better Auth to Payload CMS, allowing authentication
+ * operations to be performed against Payload collections.
+ *
+ * @param payloadClient - The Payload CMS client instance or a function that returns it
+ * @param config - Configuration options for the adapter
+ * @returns A function that creates a Better Auth adapter
+ */ const payloadAdapter = ({ payloadClient, adapterConfig })=>{
+    /**
+   * Logs debug messages if debug logging is enabled
+   * @param message - The message to log
+   */ function debugLog(message) {
+        if (adapterConfig.enableDebugLogs) {
+            // Use payload logger if available, otherwise fall back to console for package compatibility
+            if (typeof payloadClient !== 'function' && payloadClient && 'logger' in payloadClient) {
+                const payload = payloadClient;
+                if (payload.logger) {
+                    payload.logger.debug(DEBUG_LOG_PREFIX, {
+                        message
+                    });
+                } else {
+                    console.log(DEBUG_LOG_PREFIX, ...message);
+                }
+            } else {
+                console.log(DEBUG_LOG_PREFIX, ...message);
+            }
+        }
+    }
+    /**
+   * Logs error messages
+   * @param message - The error message to log
+   */ function errorLog(message) {
+        // Use payload logger if available, otherwise fall back to console for package compatibility
+        if (typeof payloadClient !== 'function' && payloadClient && 'logger' in payloadClient) {
+            const payload = payloadClient;
+            if (payload.logger) {
+                payload.logger.error(DEBUG_LOG_PREFIX, {
+                    message
+                });
+            } else {
+                console.error(DEBUG_LOG_PREFIX, ...message);
+            }
+        } else {
+            console.error(DEBUG_LOG_PREFIX, ...message);
+        }
+    }
+    /**
+   * Throws an error when a collection slug doesn't exist
+   * @param model - The model name that couldn't be found
+   * @throws {BetterAuthError} When the collection doesn't exist
+   * @returns Never - Function always throws
+   */ function collectionSlugError(model) {
+        throw new BetterAuthError(`Collection ${model} does not exist. Please check your payload collection slugs match the better auth schema`);
+    }
+    // Normalizes PayloadCMS delete result which can have multiple return structures
+    function normalizePayloadDocumentResult(response) {
+        if (!response) {
+            return null;
+        }
+        if (typeof response === 'object' && 'docs' in response) {
+            // PayloadCMS delete can return docs array with dynamic document structures
+            // Using Record<string, unknown> because document structure varies by collection and cannot be strictly typed
+            const docs = response.docs;
+            if (Array.isArray(docs) && docs.length > 0) {
+                return docs[0] ?? null;
+            }
+            return null;
+        }
+        // PayloadCMS delete result can be a single document with dynamic structure
+        return response;
+    }
+    /**
+   * Validates that a collection exists in Payload
+   * @param payload - The Payload client instance
+   * @param collectionSlug - The collection slug to validate
+   * @param model - The model name for error messages
+   * @throws {BetterAuthError} When the collection doesn't exist
+   */ async function validateCollection(payload, collectionSlug, model) {
+        if (!collectionSlug || !(collectionSlug in payload.collections)) {
+            collectionSlugError(model);
+        }
+    }
+    /**
+   * Creates a context object for Payload operations
+   * @param data - Data to include in the context
+   * @returns The context object with Better Auth metadata
+   */ // PayloadCMS context accepts dynamic metadata structures for adapter tracking
+    const createAdapterContext = (// Using Record<string, unknown> because context data structure varies by operation and cannot be strictly typed
+    data)=>({
+            [BETTER_AUTH_CONTEXT_KEY]: {
+                ...data
+            }
+        });
+    /**
+   * Resolves the Payload client, handling both function and direct references
+   * @returns The resolved Payload client
+   * @throws {BetterAuthError} When Better Auth plugin is not configured
+   */ async function resolvePayloadClient() {
+        const payload = typeof payloadClient === 'function' ? await payloadClient() : await payloadClient;
+        if (!payload.config?.custom?.hasBetterAuthPlugin) {
+            throw new BetterAuthError('Payload is not configured with the better-auth plugin. Please add the plugin to your payload config.');
+        }
+        return payload;
+    }
+    /**
+   * Creates and returns a Better Auth adapter for Payload
+   * @param options - Better Auth options
+   * @returns A Better Auth adapter implementation
+   */ return (options)=>{
+        const { transformInput, transformOutput, convertWhereClause, convertSelect, convertSort, getCollectionSlug, singleIdQuery } = createTransform(options, adapterConfig.enableDebugLogs ?? false);
+        return {
+            id: 'payload-adapter',
+            async transaction (callback) {
+                return await callback(this);
+            },
+            // Better Auth create accepts dynamic data structures that vary by model
+            async create ({ model, data: values, select }) {
+                const start = Date.now();
+                const payload = await resolvePayloadClient();
+                const collectionSlug = getCollectionSlug(model);
+                // Validate collection exists before proceeding
+                await validateCollection(payload, collectionSlug, model);
+                const transformedInput = transformInput({
+                    data: values,
+                    model: model,
+                    idType: adapterConfig.idType
+                });
+                debugLog([
+                    'create',
+                    {
+                        collectionSlug,
+                        transformedInput,
+                        select
+                    }
+                ]);
+                try {
+                    // PayloadCMS create accepts dynamic options (data, context, depth, select)
+                    const createOptions = {
+                        collection: collectionSlug,
+                        data: transformedInput,
+                        context: createAdapterContext({
+                            model,
+                            operation: 'create'
+                        }),
+                        depth: PAYLOAD_QUERY_DEPTH
+                    };
+                    const convertedSelect = convertSelect(model, select);
+                    if (convertedSelect) {
+                        createOptions.select = convertedSelect;
+                    }
+                    const rawResult = await payload.create(createOptions);
+                    const transformedResult = transformOutput({
+                        doc: rawResult,
+                        model: model
+                    });
+                    debugLog([
+                        'create result',
+                        {
+                            collectionSlug,
+                            transformedResult,
+                            duration: `${Date.now() - start}ms`
+                        }
+                    ]);
+                    return transformedResult;
+                } catch (error) {
+                    errorLog([
+                        'Error in creating:',
+                        model,
+                        error
+                    ]);
+                    return null;
+                }
+            },
+            async findOne ({ model, where, select }) {
+                const start = Date.now();
+                const payload = await resolvePayloadClient();
+                const collectionSlug = getCollectionSlug(model);
+                // Validate collection exists before proceeding
+                await validateCollection(payload, collectionSlug, model);
+                const payloadWhere = convertWhereClause({
+                    idType: adapterConfig.idType,
+                    model: model,
+                    where: where ?? []
+                });
+                debugLog([
+                    'findOne',
+                    {
+                        collectionSlug
+                    }
+                ]);
+                try {
+                    const singleId = singleIdQuery(payloadWhere);
+                    let result = null;
+                    if (singleId) {
+                        debugLog([
+                            'findOneByID',
+                            {
+                                collectionSlug,
+                                id: singleId
+                            }
+                        ]);
+                        // PayloadCMS findByID accepts dynamic options (context, depth, select)
+                        const findByIdOptions = {
+                            collection: collectionSlug,
+                            id: singleId,
+                            context: createAdapterContext({
+                                model,
+                                operation: 'findOneByID'
+                            }),
+                            depth: PAYLOAD_QUERY_DEPTH
+                        };
+                        const convertedSelect = convertSelect(model, select);
+                        if (convertedSelect) {
+                            findByIdOptions.select = convertedSelect;
+                        }
+                        result = await payload.findByID(findByIdOptions);
+                    } else {
+                        debugLog([
+                            'findOneByWhere',
+                            {
+                                collectionSlug,
+                                payloadWhere
+                            }
+                        ]);
+                        // PayloadCMS find accepts dynamic options (where, context, depth, select, limit)
+                        const findOptions = {
+                            collection: collectionSlug,
+                            where: payloadWhere,
+                            context: createAdapterContext({
+                                model,
+                                operation: 'findOneByWhere'
+                            }),
+                            depth: PAYLOAD_QUERY_DEPTH,
+                            limit: 1
+                        };
+                        const convertedSelect = convertSelect(model, select);
+                        if (convertedSelect) {
+                            findOptions.select = convertedSelect;
+                        }
+                        const docs = await payload.find(findOptions);
+                        result = docs.docs[0] ?? null;
+                    }
+                    const transformedResult = transformOutput({
+                        doc: result,
+                        model: model
+                    });
+                    debugLog([
+                        'findOne result',
+                        {
+                            collectionSlug,
+                            transformedResult,
+                            duration: `${Date.now() - start}ms`
+                        }
+                    ]);
+                    return transformedResult;
+                } catch (error) {
+                    if (error instanceof Error && 'status' in error && error.status === 404) {
+                        return null;
+                    }
+                    errorLog([
+                        'Error in findOne: ',
+                        error
+                    ]);
+                    return null;
+                }
+            },
+            async findMany ({ model, where, limit = 10, sortBy, offset = 0 }) {
+                const start = Date.now();
+                const payload = await resolvePayloadClient();
+                const collectionSlug = getCollectionSlug(model);
+                // Validate collection exists before proceeding
+                await validateCollection(payload, collectionSlug, model);
+                const payloadWhere = convertWhereClause({
+                    idType: adapterConfig.idType,
+                    model: model,
+                    where: where ?? []
+                });
+                debugLog([
+                    'findMany',
+                    {
+                        collectionSlug,
+                        sortBy,
+                        limit,
+                        offset
+                    }
+                ]);
+                try {
+                    let result = null;
+                    const singleId = singleIdQuery(payloadWhere);
+                    if (singleId) {
+                        debugLog([
+                            'findManyBySingleID',
+                            {
+                                collectionSlug,
+                                id: singleId
+                            }
+                        ]);
+                        const doc = await payload.findByID({
+                            collection: collectionSlug,
+                            id: singleId,
+                            depth: PAYLOAD_QUERY_DEPTH,
+                            context: createAdapterContext({
+                                model,
+                                operation: 'findManyBySingleID'
+                            })
+                        });
+                        result = {
+                            docs: doc ? [
+                                doc
+                            ] : [],
+                            totalDocs: doc ? 1 : 0
+                        };
+                    } else {
+                        debugLog([
+                            'findManyByWhere',
+                            {
+                                collectionSlug,
+                                payloadWhere
+                            }
+                        ]);
+                        const spill = offset % limit;
+                        const page = Math.floor(offset / limit) + 1;
+                        const fetchLimit = spill ? limit + spill : limit;
+                        const convertedSort = convertSort(model, sortBy);
+                        // PayloadCMS find accepts dynamic arguments (where, sort, limit, page, depth, context)
+                        const findArgs = {
+                            collection: collectionSlug,
+                            where: payloadWhere,
+                            limit: fetchLimit,
+                            page,
+                            depth: PAYLOAD_QUERY_DEPTH,
+                            context: createAdapterContext({
+                                model,
+                                operation: 'findManyByWhere'
+                            })
+                        };
+                        if (convertedSort) {
+                            findArgs.sort = convertedSort;
+                        }
+                        const res = await payload.find(findArgs);
+                        result = {
+                            docs: res.docs.slice(spill, spill + limit),
+                            totalDocs: res.totalDocs
+                        };
+                    }
+                    const transformedResult = result?.docs.map((doc)=>transformOutput({
+                            doc,
+                            model: model
+                        })) ?? [];
+                    debugLog([
+                        'findMany result',
+                        {
+                            collectionSlug,
+                            transformedResult,
+                            duration: `${Date.now() - start}ms`
+                        }
+                    ]);
+                    return transformedResult;
+                } catch (error) {
+                    if (error instanceof Error && 'status' in error && error.status === 404) {
+                        return [];
+                    }
+                    errorLog([
+                        'Error in findMany: ',
+                        error
+                    ]);
+                    return [];
+                }
+            },
+            async update ({ model, where, update }) {
+                const start = Date.now();
+                const payload = await resolvePayloadClient();
+                const collectionSlug = getCollectionSlug(model);
+                // Validate collection exists before proceeding
+                await validateCollection(payload, collectionSlug, model);
+                const payloadWhere = convertWhereClause({
+                    idType: adapterConfig.idType,
+                    model: model,
+                    where: where ?? []
+                });
+                const transformedInput = transformInput({
+                    data: update,
+                    model: model,
+                    idType: adapterConfig.idType
+                });
+                debugLog([
+                    'update',
+                    {
+                        collectionSlug,
+                        update
+                    }
+                ]);
+                try {
+                    let result = null;
+                    const id = singleIdQuery(payloadWhere);
+                    if (id) {
+                        debugLog([
+                            'updateByID',
+                            {
+                                collectionSlug,
+                                id
+                            }
+                        ]);
+                        const updateResponse = await payload.update({
+                            collection: collectionSlug,
+                            id,
+                            data: transformedInput,
+                            depth: PAYLOAD_QUERY_DEPTH,
+                            context: createAdapterContext({
+                                model,
+                                operation: 'updateByID'
+                            })
+                        });
+                        result = normalizePayloadDocumentResult(updateResponse);
+                    } else {
+                        debugLog([
+                            'updateByWhere',
+                            {
+                                collectionSlug,
+                                payloadWhere
+                            }
+                        ]);
+                        const updateResponse = await payload.update({
+                            collection: collectionSlug,
+                            where: payloadWhere,
+                            data: transformedInput,
+                            depth: PAYLOAD_QUERY_DEPTH,
+                            context: createAdapterContext({
+                                model,
+                                operation: 'updateByWhere'
+                            })
+                        });
+                        result = normalizePayloadDocumentResult(updateResponse);
+                    }
+                    const transformedResult = transformOutput({
+                        doc: result,
+                        model: model
+                    });
+                    debugLog([
+                        'update-result',
+                        {
+                            collectionSlug,
+                            transformedResult,
+                            duration: `${Date.now() - start}ms`
+                        }
+                    ]);
+                    return transformedResult;
+                } catch (error) {
+                    if (error instanceof Error && 'status' in error && error.status === 404) {
+                        return null;
+                    }
+                    errorLog([
+                        'Error in update: ',
+                        error
+                    ]);
+                    return null;
+                }
+            },
+            async updateMany ({ model, where, update }) {
+                const start = Date.now();
+                const payload = await resolvePayloadClient();
+                const collectionSlug = getCollectionSlug(model);
+                // Validate collection exists before proceeding
+                await validateCollection(payload, collectionSlug, model);
+                const payloadWhere = convertWhereClause({
+                    idType: adapterConfig.idType,
+                    model: model,
+                    where: where ?? []
+                });
+                const transformedInput = transformInput({
+                    data: update,
+                    model: model,
+                    idType: adapterConfig.idType
+                });
+                debugLog([
+                    'updateMany',
+                    {
+                        collectionSlug,
+                        payloadWhere,
+                        update
+                    }
+                ]);
+                try {
+                    const updateResponse = await payload.update({
+                        collection: collectionSlug,
+                        where: payloadWhere,
+                        data: transformedInput,
+                        depth: PAYLOAD_QUERY_DEPTH,
+                        context: createAdapterContext({
+                            model,
+                            operation: 'updateMany'
+                        })
+                    });
+                    // PayloadCMS updateMany can return docs array with dynamic document structures
+                    // Using Record<string, unknown> because document structure varies by collection and cannot be strictly typed
+                    const updateDocs = updateResponse && typeof updateResponse === 'object' && 'docs' in updateResponse && Array.isArray(updateResponse.docs) ? updateResponse.docs ?? [] : [];
+                    debugLog([
+                        'updateMany result',
+                        {
+                            collectionSlug,
+                            result: updateDocs,
+                            duration: `${Date.now() - start}ms`
+                        }
+                    ]);
+                    return updateDocs.length;
+                } catch (error) {
+                    if (error instanceof Error && 'status' in error && error.status === 404) {
+                        return 0;
+                    }
+                    errorLog([
+                        'Error in updateMany: ',
+                        error
+                    ]);
+                    return 0;
+                }
+            },
+            async delete ({ model, where }) {
+                const start = Date.now();
+                const payload = await resolvePayloadClient();
+                const collectionSlug = getCollectionSlug(model);
+                // Validate collection exists before proceeding
+                await validateCollection(payload, collectionSlug, model);
+                const payloadWhere = convertWhereClause({
+                    idType: adapterConfig.idType,
+                    model: model,
+                    where: where ?? []
+                });
+                debugLog([
+                    'delete',
+                    {
+                        collectionSlug
+                    }
+                ]);
+                try {
+                    let deleteResult = null;
+                    const singleId = singleIdQuery(payloadWhere);
+                    if (singleId) {
+                        debugLog([
+                            'deleteByID',
+                            {
+                                collectionSlug,
+                                id: singleId
+                            }
+                        ]);
+                        const deleteResponse = await payload.delete({
+                            collection: collectionSlug,
+                            id: singleId,
+                            depth: PAYLOAD_QUERY_DEPTH,
+                            context: createAdapterContext({
+                                model,
+                                operation: 'deleteByID'
+                            })
+                        });
+                        const deletedDoc = normalizePayloadDocumentResult(deleteResponse);
+                        deleteResult = {
+                            doc: deletedDoc,
+                            errors: []
+                        };
+                    } else {
+                        debugLog([
+                            'deleteByWhere',
+                            {
+                                collectionSlug,
+                                payloadWhere
+                            }
+                        ]);
+                        const deleteResponse = await payload.delete({
+                            collection: collectionSlug,
+                            where: payloadWhere,
+                            depth: PAYLOAD_QUERY_DEPTH,
+                            context: createAdapterContext({
+                                model,
+                                operation: 'deleteByWhere'
+                            })
+                        });
+                        const deletedDoc = normalizePayloadDocumentResult(deleteResponse);
+                        deleteResult = {
+                            doc: deletedDoc,
+                            errors: []
+                        };
+                    }
+                    debugLog([
+                        'delete result',
+                        {
+                            collectionSlug,
+                            result: deleteResult,
+                            duration: `${Date.now() - start}ms`
+                        }
+                    ]);
+                } catch (error) {
+                    if (error instanceof Error && 'status' in error && error.status === 404) {
+                        return;
+                    }
+                    errorLog([
+                        'Error in delete: ',
+                        error
+                    ]);
+                }
+            },
+            async deleteMany ({ model, where }) {
+                const start = Date.now();
+                const payload = await resolvePayloadClient();
+                const collectionSlug = getCollectionSlug(model);
+                // Validate collection exists before proceeding
+                await validateCollection(payload, collectionSlug, model);
+                const payloadWhere = convertWhereClause({
+                    idType: adapterConfig.idType,
+                    model: model,
+                    where: where ?? []
+                });
+                debugLog([
+                    'deleteMany',
+                    {
+                        collectionSlug,
+                        payloadWhere
+                    }
+                ]);
+                try {
+                    const deleteResponse = await payload.delete({
+                        collection: collectionSlug,
+                        where: payloadWhere,
+                        depth: PAYLOAD_QUERY_DEPTH,
+                        context: createAdapterContext({
+                            model,
+                            operation: 'deleteMany'
+                        })
+                    });
+                    const deleteDocsLength = (()=>{
+                        if (!deleteResponse) {
+                            return 0;
+                        }
+                        // PayloadCMS deleteMany can return docs array with dynamic document structures
+                        // Using Record<string, unknown> because document structure varies by collection and cannot be strictly typed
+                        if (typeof deleteResponse === 'object' && 'docs' in deleteResponse && Array.isArray(deleteResponse.docs)) {
+                            return (deleteResponse.docs ?? []).length;
+                        }
+                        return 1;
+                    })();
+                    debugLog([
+                        'deleteMany result',
+                        {
+                            collectionSlug,
+                            result: deleteResponse,
+                            duration: `${Date.now() - start}ms`
+                        }
+                    ]);
+                    return deleteDocsLength;
+                } catch (error) {
+                    if (error instanceof Error && 'status' in error && error.status === 404) {
+                        return 0;
+                    }
+                    errorLog([
+                        'Error in deleteMany: ',
+                        error
+                    ]);
+                    return 0;
+                }
+            },
+            async count ({ model, where }) {
+                const start = Date.now();
+                const payload = await resolvePayloadClient();
+                const collectionSlug = getCollectionSlug(model);
+                // Validate collection exists before proceeding
+                await validateCollection(payload, collectionSlug, model);
+                const payloadWhere = convertWhereClause({
+                    idType: adapterConfig.idType,
+                    model: model,
+                    where: where ?? []
+                });
+                debugLog([
+                    'count',
+                    {
+                        collectionSlug,
+                        payloadWhere
+                    }
+                ]);
+                try {
+                    const result = await payload.count({
+                        collection: collectionSlug,
+                        where: payloadWhere,
+                        depth: PAYLOAD_QUERY_DEPTH,
+                        context: createAdapterContext({
+                            model,
+                            operation: 'count'
+                        })
+                    });
+                    debugLog([
+                        'count result',
+                        {
+                            collectionSlug,
+                            result: {
+                                totalDocs: result.totalDocs
+                            },
+                            duration: `${Date.now() - start}ms`
+                        }
+                    ]);
+                    return result.totalDocs;
+                } catch (error) {
+                    if (error instanceof Error && 'status' in error && error.status === 404) {
+                        return 0;
+                    }
+                    errorLog([
+                        'Error in count: ',
+                        error
+                    ]);
+                    return 0;
+                }
+            },
+            createSchema: async (options, file)=>{
+                const schemaCode = await generateSchema(options);
+                return {
+                    code: schemaCode,
+                    path: file || 'schema.ts',
+                    append: false,
+                    overwrite: true
+                };
+            }
+        };
+    };
+};
+export { generateSchema, payloadAdapter };
+
+//# sourceMappingURL=index.js.map