@convex-dev/better-auth 0.11.3 → 0.11.4

package/dist/test/adapter-factory/basic.js

@@ -1,24 +1,13 @@
-import { createTestSuite } from "@better-auth/test-utils/adapter";
-import { organization } from "better-auth/plugins/organization";
+import { getNormalTestSuiteTests as getUpstreamNormalTestSuiteTests } from "@better-auth/test-utils/adapter";
 import { expect } from "vitest";
-/**
- * This test suite tests the basic CRUD operations of the adapter.
- */
-export const normalTestSuite = createTestSuite("normal", {}, (helpers, debugTools) => {
-    const tests = getNormalTestSuiteTests(helpers, debugTools);
+const toMillis = (value) => value instanceof Date ? value.getTime() : value;
+export const getNormalTestSuiteTests = (helpers, debugTools) => {
+    const tests = getUpstreamNormalTestSuiteTests(helpers, debugTools);
+    const { adapter, generate, getBetterAuthOptions, insertRandom, modifyBetterAuthOptions, sortModels, transformGeneratedModel, } = helpers;
     return {
-        "init - tests": async () => {
-            const opts = helpers.getBetterAuthOptions();
-            expect(opts.advanced?.database?.generateId !== "serial").toBeTruthy();
-        },
         ...tests,
-    };
-});
-export const getNormalTestSuiteTests = ({ adapter, generate, insertRandom, modifyBetterAuthOptions, sortModels, customIdGenerator, getBetterAuthOptions, transformGeneratedModel, transformIdOutput, }, debugTools) => {
-    return {
         "create - should create a model": async () => {
             const user = await generate("user");
-            // console.log(`pre-transformed:`, user);
             const result = await adapter.create({
                 model: "user",
                 data: user,
@@ -31,461 +20,12 @@ export const getNormalTestSuiteTests = ({ adapter, generate, insertRandom, modif
             }
             expect(typeof result.id).toEqual("string");
             const transformed = transformGeneratedModel(user);
-            // console.log(`transformed:`, transformed);
-            // console.log(`result:`, result);
             expect(result).toEqual({
                 ...transformed,
                 createdAt: new Date(user.createdAt).getTime(),
                 updatedAt: new Date(user.updatedAt).getTime(),
             });
         },
-        "create - should always return an id": async () => {
-            const { id: _, ...user } = await generate("user");
-            const res = await adapter.create({
-                model: "user",
-                data: user,
-            });
-            expect(res).toHaveProperty("id");
-            expect(typeof res.id).toEqual("string");
-        },
-        "create - should use generateId if provided": async () => {
-            const ID = (await customIdGenerator?.()) || "MOCK-ID";
-            await modifyBetterAuthOptions({
-                advanced: {
-                    database: {
-                        generateId: () => ID,
-                    },
-                },
-            }, false);
-            const { id: _, ...user } = await generate("user");
-            const res = await adapter.create({
-                model: "user",
-                data: user,
-            });
-            expect(res.id).toEqual(transformIdOutput ? transformIdOutput(ID) : ID);
-            const findResult = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: res.id }],
-            });
-            expect(findResult).toEqual(res);
-        },
-        "create - should return null for nullable foreign keys": {
-            migrateBetterAuth: {
-                plugins: [
-                    {
-                        id: "nullable-test",
-                        schema: {
-                            testModel: {
-                                fields: {
-                                    nullableReference: {
-                                        type: "string",
-                                        references: { field: "id", model: "user" },
-                                        required: false,
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ],
-            },
-            test: async () => {
-                const { nullableReference } = await adapter.create({
-                    model: "testModel",
-                    data: { nullableReference: null },
-                    forceAllowId: true,
-                });
-                expect(nullableReference).toBeNull();
-            },
-        },
-        "create - should apply default values to fields": async () => {
-            await modifyBetterAuthOptions({
-                user: {
-                    additionalFields: {
-                        testField: {
-                            type: "string",
-                            defaultValue: "test-value",
-                        },
-                        cbDefaultValueField: {
-                            type: "string",
-                            defaultValue: () => {
-                                return "advanced-test-value";
-                            },
-                        },
-                    },
-                },
-                plugins: [
-                    {
-                        id: "default-fields-test",
-                        schema: {
-                            testModel: {
-                                fields: {
-                                    testField: {
-                                        type: "string",
-                                        defaultValue: "test-value",
-                                    },
-                                    cbDefaultValueField: {
-                                        type: "string",
-                                        defaultValue: () => {
-                                            return "advanced-test-value";
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ],
-            }, true);
-            const result = await adapter.create({
-                model: "testModel",
-                data: {},
-            });
-            expect(result.id).toBeDefined();
-            expect(result.id).toBeTypeOf("string");
-            expect(result.testField).toBe("test-value");
-            expect(result.cbDefaultValueField).toBe("advanced-test-value");
-            const userResult = await adapter.create({
-                model: "user",
-                data: {
-                    ...(await generate("user")),
-                },
-                forceAllowId: true,
-            });
-            expect(userResult).toBeDefined();
-            expect(userResult?.testField).toBe("test-value");
-            expect(userResult?.cbDefaultValueField).toBe("advanced-test-value");
-        },
-        "findOne - should find a model": async () => {
-            const [user] = await insertRandom("user");
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: user.id }],
-            });
-            expect(result).toEqual(user);
-        },
-        "findOne - should not apply defaultValue if value not found": async () => {
-            await modifyBetterAuthOptions({
-                user: {
-                    additionalFields: {
-                        testField: {
-                            type: "string",
-                            required: false,
-                            defaultValue: "test-value",
-                        },
-                        cbDefaultValueField: {
-                            type: "string",
-                            required: false,
-                            defaultValue: () => {
-                                return "advanced-test-value";
-                            },
-                        },
-                    },
-                },
-                plugins: [
-                    {
-                        id: "default-fields-test",
-                        schema: {
-                            testModel: {
-                                fields: {
-                                    testField: {
-                                        type: "string",
-                                        required: false,
-                                        defaultValue: "test-value",
-                                    },
-                                    cbDefaultValueField: {
-                                        type: "string",
-                                        required: false,
-                                        defaultValue: () => {
-                                            return "advanced-test-value";
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ],
-            }, true);
-            const first = await adapter.create({
-                model: "testModel",
-                data: {
-                    testField: null,
-                    cbDefaultValueField: null,
-                },
-            });
-            const second = await adapter.create({
-                model: "user",
-                data: {
-                    ...(await generate("user")),
-                    testField: null,
-                    cbDefaultValueField: null,
-                },
-                forceAllowId: true,
-            });
-            const result = await adapter.findOne({
-                model: "testModel",
-                where: [{ field: "id", value: first.id }],
-            });
-            expect(result).not.toBeNull();
-            expect(result?.testField).toBeNull();
-            expect(result?.cbDefaultValueField).toBeNull();
-            const resultTwo = await adapter.findMany({
-                model: "user",
-                where: [{ field: "id", value: second.id }],
-            });
-            expect(resultTwo).not.toBeNull();
-            expect(resultTwo.length).toBe(1);
-            expect(resultTwo[0]?.testField).toBeNull();
-            expect(resultTwo[0]?.cbDefaultValueField).toBeNull();
-        },
-        "findOne - should find a model using a reference field": async () => {
-            const [user, session] = await insertRandom("session");
-            const result = await adapter.findOne({
-                model: "session",
-                where: [{ field: "userId", value: user.id }],
-            });
-            expect(result).toEqual(session);
-        },
-        "findOne - should not throw on record not found": async () => {
-            const options = getBetterAuthOptions();
-            const useUUIDs = options.advanced?.database?.generateId === "uuid";
-            const result = await adapter.findOne({
-                model: "user",
-                where: [
-                    { field: "id", value: useUUIDs ? crypto.randomUUID() : "100000" },
-                ],
-            });
-            expect(result).toBeNull();
-        },
-        "findOne - should find a model without id": async () => {
-            const [user] = await insertRandom("user");
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "email", value: user.email }],
-            });
-            expect(result).toEqual(user);
-        },
-        "findOne - should find a model with join": async () => {
-            const users = [];
-            const sessions = [];
-            const accounts = [];
-            for (const _ of Array.from({ length: 3 })) {
-                const user = await adapter.create({
-                    model: "user",
-                    data: {
-                        ...(await generate("user")),
-                    },
-                    forceAllowId: true,
-                });
-                users.push(user);
-                const userId = users[0].id;
-                const session = await adapter.create({
-                    model: "session",
-                    data: {
-                        ...(await generate("session")),
-                        userId,
-                    },
-                    forceAllowId: true,
-                });
-                sessions.push(session);
-                const account = await adapter.create({
-                    model: "account",
-                    data: {
-                        ...(await generate("account")),
-                        userId,
-                    },
-                    forceAllowId: true,
-                });
-                accounts.push(account);
-            }
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: users[0].id }],
-                join: {
-                    session: true,
-                    account: true,
-                },
-            });
-            expect({
-                ...result,
-                session: result?.session.sort((a, b) => a.id.localeCompare(b.id)),
-                account: result?.account.sort((a, b) => a.id.localeCompare(b.id)),
-            }).toEqual({
-                ...users[0],
-                session: sessions.sort((a, b) => a.id.localeCompare(b.id)),
-                account: accounts.sort((a, b) => a.id.localeCompare(b.id)),
-            });
-        },
-        "findOne - should find a model with modified field name": async () => {
-            await modifyBetterAuthOptions({
-                user: {
-                    fields: {
-                        email: "email_address",
-                    },
-                },
-            }, true);
-            const [user] = await insertRandom("user");
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "email", value: user.email }],
-            });
-            expect(result).toEqual(user);
-            expect(result?.email).toEqual(user.email);
-            expect(true).toEqual(true);
-        },
-        "findOne - should find a model with modified model name": async () => {
-            await modifyBetterAuthOptions({
-                user: {
-                    modelName: "user_custom",
-                },
-            }, true);
-            const [user] = await insertRandom("user");
-            expect(user).toBeDefined();
-            expect(user).toHaveProperty("id");
-            expect(user).toHaveProperty("name");
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "email", value: user.email }],
-            });
-            expect(result).toEqual(user);
-            expect(result?.email).toEqual(user.email);
-            expect(true).toEqual(true);
-        },
-        "findOne - should find a model with additional fields": async () => {
-            await modifyBetterAuthOptions({
-                user: {
-                    additionalFields: {
-                        customField: {
-                            type: "string",
-                            input: false,
-                            required: true,
-                            defaultValue: "default-value",
-                        },
-                    },
-                },
-            }, true);
-            const [user_] = await insertRandom("user");
-            const user = user_;
-            expect(user).toHaveProperty("customField");
-            expect(user.customField).toBe("default-value");
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "customField", value: user.customField }],
-            });
-            expect(result).toEqual(user);
-            expect(result?.customField).toEqual("default-value");
-        },
-        "findOne - should select fields": async () => {
-            const [user] = await insertRandom("user");
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: user.id }],
-                select: ["email", "name"],
-            });
-            expect(result).toEqual({ email: user.email, name: user.name });
-        },
-        "findOne - should select fields with one-to-many join": async () => {
-            const user = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            const session = await adapter.create({
-                model: "session",
-                data: { ...(await generate("session")), userId: user.id },
-                forceAllowId: true,
-            });
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: user.id }],
-                select: ["email", "name"],
-                join: { session: true },
-            });
-            expect(result).toBeDefined();
-            expect(result?.email).toEqual(user.email);
-            expect(result?.name).toEqual(user.name);
-            expect(result?.session).toBeDefined();
-            expect(Array.isArray(result?.session)).toBe(true);
-            expect(result?.session).toHaveLength(1);
-            expect(result?.session[0]).toEqual(session);
-        },
-        "findOne - should select fields with one-to-one join": async () => {
-            await modifyBetterAuthOptions({
-                plugins: [
-                    {
-                        id: "one-to-one-test",
-                        schema: {
-                            oneToOneTable: {
-                                fields: {
-                                    oneToOne: {
-                                        type: "string",
-                                        required: true,
-                                        references: { field: "id", model: "user" },
-                                        unique: true,
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ],
-            }, true);
-            const user = await adapter.create({
-                model: "user",
-                data: {
-                    ...(await generate("user")),
-                },
-                forceAllowId: true,
-            });
-            const oneToOne = await adapter.create({
-                model: "oneToOneTable",
-                data: {
-                    oneToOne: user.id,
-                },
-            });
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: user.id }],
-                select: ["email", "name"],
-                join: { oneToOneTable: true },
-            });
-            expect(result).toBeDefined();
-            expect(result?.email).toEqual(user.email);
-            expect(result?.name).toEqual(user.name);
-            expect(result?.oneToOneTable).toBeDefined();
-            expect(result?.oneToOneTable).toEqual(oneToOne);
-        },
-        "findOne - should select fields with multiple joins": async () => {
-            const user = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            const session = await adapter.create({
-                model: "session",
-                data: { ...(await generate("session")), userId: user.id },
-                forceAllowId: true,
-            });
-            const account = await adapter.create({
-                model: "account",
-                data: { ...(await generate("account")), userId: user.id },
-                forceAllowId: true,
-            });
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: user.id }],
-                select: ["email", "name"],
-                join: { session: true, account: true },
-            });
-            expect(result).toBeDefined();
-            expect(result?.email).toEqual(user.email);
-            expect(result?.name).toEqual(user.name);
-            expect(result?.session).toBeDefined();
-            expect(Array.isArray(result?.session)).toBe(true);
-            expect(result?.session).toHaveLength(1);
-            expect(result?.session[0]).toEqual(session);
-            expect(result?.account).toBeDefined();
-            expect(Array.isArray(result?.account)).toBe(true);
-            expect(result?.account).toHaveLength(1);
-            expect(result?.account[0]).toEqual(account);
-        },
         "findOne - should find model with date field": async () => {
             const [user] = await insertRandom("user");
             const result = await adapter.findOne({
@@ -496,28 +36,7 @@ export const getNormalTestSuiteTests = ({ adapter, generate, insertRandom, modif
             expect(typeof result?.createdAt).toBe("number");
             expect(result?.createdAt).toEqual(user.createdAt);
         },
-        "findOne - should perform backwards joins": async () => {
-            const user = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            const session = await adapter.create({
-                model: "session",
-                data: { ...(await generate("session")), userId: user.id },
-                forceAllowId: true,
-            });
-            const result = await adapter.findOne({
-                model: "session",
-                where: [{ field: "token", value: session.token }],
-                join: { user: true },
-            });
-            expect(result).toEqual({
-                ...session,
-                user: user,
-            });
-        },
-        "findOne - should return an object for one-to-one joins": async () => {
+        "findOne - should work with both one-to-one and one-to-many joins": async () => {
             await modifyBetterAuthOptions({
                 plugins: [
                     {
@@ -537,2181 +56,90 @@ export const getNormalTestSuiteTests = ({ adapter, generate, insertRandom, modif
                     },
                 ],
             }, true);
-            const users = (await insertRandom("user", 2)).map((x) => x[0]);
+            const users = (await insertRandom("user", 2)).map((entry) => entry[0]);
             const oneToOne = await adapter.create({
                 model: "oneToOneTable",
                 data: {
                     oneToOne: users[0].id,
                 },
             });
-            // decoy second table that shouldn't be included in the result
-            await adapter.create({
-                model: "oneToOneTable",
+            const session1 = await adapter.create({
+                model: "session",
+                data: {
+                    ...(await generate("session")),
+                    userId: users[0].id,
+                    createdAt: new Date(Date.now() - 3000),
+                },
+                forceAllowId: true,
+            });
+            const session2 = await adapter.create({
+                model: "session",
                 data: {
-                    oneToOne: users[1].id,
+                    ...(await generate("session")),
+                    userId: users[0].id,
+                    createdAt: new Date(Date.now() - 1000),
                 },
+                forceAllowId: true,
             });
             const result = await adapter.findOne({
                 model: "user",
                 where: [{ field: "id", value: users[0].id }],
-                join: { oneToOneTable: true },
+                join: { oneToOneTable: true, session: true },
             });
+            if (result?.session?.length) {
+                result.session = result.session.sort((a, b) => toMillis(a.createdAt) - toMillis(b.createdAt));
+            }
             expect(result).toEqual({
                 ...users[0],
                 oneToOneTable: oneToOne,
+                session: [session1, session2],
             });
         },
-        "findOne - should return an array for one-to-many joins": async () => {
-            const user = await adapter.create({
+        "findMany - should find many models with date fields": async () => {
+            const users = (await insertRandom("user", 3)).map((entry) => entry[0]);
+            const youngestUser = users.sort((a, b) => toMillis(b.createdAt) - toMillis(a.createdAt))[0];
+            const result = await adapter.findMany({
                 model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            const session = await adapter.create({
-                model: "session",
-                data: { ...(await generate("session")), userId: user.id },
-                forceAllowId: true,
+                where: [
+                    { field: "createdAt", value: youngestUser.createdAt, operator: "lt" },
+                ],
             });
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: user.id }],
-                join: { session: true },
-            });
-            expect(result).toEqual({
-                ...user,
-                session: [session],
-            });
-        },
-        "findOne - should work with both one-to-one and one-to-many joins": async () => {
-            await modifyBetterAuthOptions({
-                plugins: [
-                    {
-                        id: "one-to-one-test",
-                        schema: {
-                            oneToOneTable: {
-                                fields: {
-                                    oneToOne: {
-                                        type: "string",
-                                        required: true,
-                                        references: { field: "id", model: "user" },
-                                        unique: true,
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ],
-            }, true);
-            const users = (await insertRandom("user", 2)).map((x) => x[0]);
-            const oneToOne = await adapter.create({
-                model: "oneToOneTable",
-                data: {
-                    oneToOne: users[0].id,
-                },
-            });
-            const session1 = await adapter.create({
-                model: "session",
-                data: {
-                    ...(await generate("session")),
-                    userId: users[0].id,
-                    createdAt: new Date(Date.now() - 3000),
-                },
-                forceAllowId: true,
-            });
-            const session2 = await adapter.create({
-                model: "session",
-                data: {
-                    ...(await generate("session")),
-                    userId: users[0].id,
-                    createdAt: new Date(Date.now() - 1000),
-                },
-                forceAllowId: true,
-            });
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: users[0].id }],
-                join: { oneToOneTable: true, session: true },
-            });
-            if (result?.session?.length) {
-                result.session = result.session.sort((a, b) => a.createdAt - b.createdAt);
-            }
-            expect(result).toEqual({
-                ...users[0],
-                oneToOneTable: oneToOne,
-                session: [session1, session2],
-            });
-        },
-        "findOne - should return null for failed base model lookup that has joins": async () => {
-            await modifyBetterAuthOptions({
-                plugins: [
-                    {
-                        id: "one-to-one-test",
-                        schema: {
-                            oneToOneTable: {
-                                modelName: "one_to_one_table",
-                                fields: {
-                                    oneToOne: {
-                                        type: "string",
-                                        required: true,
-                                        references: { field: "id", model: "user" },
-                                        unique: true,
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ],
-            }, true);
-            const options = getBetterAuthOptions();
-            const useUUIDs = options.advanced?.database?.generateId === "uuid";
-            const result = await adapter.findOne({
-                model: "user",
-                where: [
-                    { field: "id", value: useUUIDs ? crypto.randomUUID() : "100000" },
-                ],
-                join: { session: true, account: true, oneToOneTable: true },
-            });
-            expect(result).toBeNull();
-        },
-        "findOne - should join a model with modified field name": async () => {
-            await modifyBetterAuthOptions({
-                user: {
-                    fields: {
-                        email: "email_address",
-                    },
-                },
-                plugins: [
-                    {
-                        id: "one-to-one-test",
-                        schema: {
-                            oneToOneTable: {
-                                modelName: "one_to_one_table",
-                                fields: {
-                                    oneToOne: {
-                                        type: "string",
-                                        required: true,
-                                        references: { field: "email", model: "user" },
-                                        unique: true,
-                                        fieldName: "one_to_one",
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ],
-            }, true);
-            const user = await adapter.create({
-                model: "user",
-                data: {
-                    ...(await generate("user")),
-                },
-                forceAllowId: true,
-            });
-            const oneToOne = await adapter.create({
-                model: "oneToOneTable",
-                data: {
-                    oneToOne: user.email,
-                },
-            });
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "email", value: user.email }],
-                join: { oneToOneTable: true },
-            });
-            expect(result).toEqual({
-                ...user,
-                oneToOneTable: oneToOne,
-            });
-        },
-        "findMany - should find many models": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            const result = await adapter.findMany({
-                model: "user",
-            });
-            expect(sortModels(result)).toEqual(sortModels(users));
-        },
-        "findMany - should find many models with date fields": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            const youngestUser = users.sort((a, b) => b.createdAt - a.createdAt)[0];
-            const result = await adapter.findMany({
-                model: "user",
-                where: [
-                    { field: "createdAt", value: youngestUser.createdAt, operator: "lt" },
-                ],
-            });
-            expect(sortModels(result)).toEqual(sortModels(users.filter((user) => user.createdAt < youngestUser.createdAt)));
-        },
-        "findMany - should find many models with join": async () => {
-            let expectedResult = [];
-            for (let i = 0; i < 10; i++) {
-                const user = await adapter.create({
-                    model: "user",
-                    data: {
-                        ...(await generate("user")),
-                        ...(i < 3 ? { name: `join-user-${i}` } : {}),
-                    },
-                    forceAllowId: true,
-                });
-                const sessions = [];
-                for (let index = 0; index < 3; index++) {
-                    const session = await adapter.create({
-                        model: "session",
-                        data: { ...(await generate("session")), userId: user.id },
-                        forceAllowId: true,
-                    });
-                    sessions.push(session);
-                }
-                const accounts = [];
-                for (let index = 0; index < 3; index++) {
-                    const account = await adapter.create({
-                        model: "account",
-                        data: { ...(await generate("account")), userId: user.id },
-                        forceAllowId: true,
-                    });
-                    accounts.push(account);
-                }
-                if (i < 3) {
-                    expectedResult.push({
-                        ...user,
-                        session: sessions,
-                        account: accounts,
-                    });
-                }
-            }
-            let result = await adapter.findMany({
-                model: "user",
-                where: [{ field: "name", value: "join-user", operator: "starts_with" }],
-                join: {
-                    session: true,
-                    account: true,
-                },
-            });
-            // sort both results since order in this case doesn't matter
-            // but the test requires the order to be consistent
-            const sort = (a, b) => a.id.localeCompare(b.id);
-            result = result.sort(sort);
-            result = result.map((x) => ({
-                ...x,
-                session: x.session.sort((a, b) => a.id.localeCompare(b.id)),
-                account: x.account.sort((a, b) => a.id.localeCompare(b.id)),
-            }));
-            expectedResult = expectedResult.sort(sort);
-            expectedResult = expectedResult.map((x) => ({
-                ...x,
-                session: x.session.sort((a, b) => a.id.localeCompare(b.id)),
-                account: x.account.sort((a, b) => a.id.localeCompare(b.id)),
-            }));
-            expect(result).toEqual(expectedResult);
-        },
-        "findMany - should find many with join and limit": async () => {
-            const users = [];
-            const sessionsByUser = new Map();
-            for (let i = 0; i < 5; i++) {
-                const user = await adapter.create({
-                    model: "user",
-                    data: { ...(await generate("user")) },
-                    forceAllowId: true,
-                });
-                users.push(user);
-                sessionsByUser.set(user.id, []);
-                for (let j = 0; j < 3; j++) {
-                    const session = await adapter.create({
-                        model: "session",
-                        data: { ...(await generate("session")), userId: user.id },
-                        forceAllowId: true,
-                    });
-                    sessionsByUser.get(user.id).push(session);
-                }
-            }
-            const result = await adapter.findMany({
-                model: "user",
-                join: { session: true },
-                limit: 2,
-            });
-            expect(result).toHaveLength(2);
-            result.forEach((user) => {
-                expect(user.session).toHaveLength(3);
-            });
-        },
-        "findMany - should select fields": async () => {
-            const expectedResults = (await insertRandom("user", 3)).map(([{ id, email }]) => ({ id, email }));
-            const select = ["id", "email"];
-            const result = await adapter.findMany({
-                model: "user",
-                where: [
-                    {
-                        field: "id",
-                        value: expectedResults.map((r) => r.id),
-                        operator: "in",
-                    },
-                ],
-                select,
-            });
-            expect(result.length).toEqual(expectedResults.length);
-            expect(result[0]).toSatisfy((obj) => expectedResults.some((r) => r.id === obj.id && r.email === obj.email) &&
-                Object.entries(obj).every(([k, v]) => select.includes(k) || v === undefined));
-        },
-        "findMany - should select fields with one-to-many join": async () => {
-            const user = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            const session = await adapter.create({
-                model: "session",
-                data: { ...(await generate("session")), userId: user.id },
-                forceAllowId: true,
-            });
-            const [result] = await adapter.findMany({
-                model: "user",
-                where: [{ field: "id", value: user.id }],
-                select: ["email", "name"],
-                join: { session: true },
-            });
-            expect(result).toBeDefined();
-            expect(result?.email).toEqual(user.email);
-            expect(result?.name).toEqual(user.name);
-            expect(result?.session).toBeDefined();
-            expect(Array.isArray(result?.session)).toBe(true);
-            expect(result?.session).toHaveLength(1);
-            expect(result?.session[0]).toEqual(session);
-        },
-        "findMany - should select fields with one-to-one join": async () => {
-            await modifyBetterAuthOptions({
-                plugins: [
-                    {
-                        id: "one-to-one-test",
-                        schema: {
-                            oneToOneTable: {
-                                fields: {
-                                    oneToOne: {
-                                        type: "string",
-                                        required: true,
-                                        references: { field: "id", model: "user" },
-                                        unique: true,
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ],
-            }, true);
-            const user = await adapter.create({
-                model: "user",
-                data: {
-                    ...(await generate("user")),
-                },
-                forceAllowId: true,
-            });
-            const oneToOne = await adapter.create({
-                model: "oneToOneTable",
-                data: {
-                    oneToOne: user.id,
-                },
-            });
-            const [result] = await adapter.findMany({
-                model: "user",
-                where: [{ field: "id", value: user.id }],
-                select: ["email", "name"],
-                join: { oneToOneTable: true },
-            });
-            expect(result).toBeDefined();
-            expect(result?.email).toEqual(user.email);
-            expect(result?.name).toEqual(user.name);
-            expect(result?.oneToOneTable).toBeDefined();
-            expect(result?.oneToOneTable).toEqual(oneToOne);
-        },
-        "findMany - should select fields with multiple joins": async () => {
-            const user = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            const session = await adapter.create({
-                model: "session",
-                data: { ...(await generate("session")), userId: user.id },
-                forceAllowId: true,
-            });
-            const account = await adapter.create({
-                model: "account",
-                data: { ...(await generate("account")), userId: user.id },
-                forceAllowId: true,
-            });
-            const [result] = await adapter.findMany({
-                model: "user",
-                where: [{ field: "id", value: user.id }],
-                select: ["email", "name"],
-                join: { session: true, account: true },
-            });
-            expect(result).toBeDefined();
-            expect(result?.email).toEqual(user.email);
-            expect(result?.name).toEqual(user.name);
-            expect(result?.session).toBeDefined();
-            expect(Array.isArray(result?.session)).toBe(true);
-            expect(result?.session).toHaveLength(1);
-            expect(result?.session[0]).toEqual(session);
-            expect(result?.account).toBeDefined();
-            expect(Array.isArray(result?.account)).toBe(true);
-            expect(result?.account).toHaveLength(1);
-            expect(result?.account[0]).toEqual(account);
-        },
-        "findMany - should find many with join and offset": async () => {
-            const users = [];
-            for (let i = 0; i < 5; i++) {
-                const user = await adapter.create({
-                    model: "user",
-                    data: {
-                        ...(await generate("user")),
-                        name: `user-${i.toString().padStart(2, "0")}`,
-                    },
-                    forceAllowId: true,
-                });
-                users.push(user);
-                for (let j = 0; j < 2; j++) {
-                    await adapter.create({
-                        model: "session",
-                        data: { ...(await generate("session")), userId: user.id },
-                        forceAllowId: true,
-                    });
-                }
-            }
-            const result = await adapter.findMany({
-                model: "user",
-                join: { session: true },
-                offset: 2,
-            });
-            expect(result.length).toBe(3);
-        },
-        "findMany - should find many with join and sortBy": async () => {
-            let n = -1;
-            await modifyBetterAuthOptions({
-                user: {
-                    additionalFields: {
-                        numericField: {
-                            type: "number",
-                            defaultValue() {
-                                return ++n;
-                            },
-                        },
-                    },
-                },
-            }, true);
-            const users = [];
-            for (let i = 0; i < 5; i++) {
-                const user = (await adapter.create({
-                    model: "user",
-                    data: { ...(await generate("user")) },
-                    forceAllowId: true,
-                }));
-                users.push(user);
-                for (let j = 0; j < 2; j++) {
-                    await adapter.create({
-                        model: "session",
-                        data: { ...(await generate("session")), userId: user.id },
-                        forceAllowId: true,
-                    });
-                }
-            }
-            const result = await adapter.findMany({
-                model: "user",
-                join: { session: true },
-                sortBy: { field: "numericField", direction: "desc" },
-            });
-            expect(result[0].numericField).toBeGreaterThan(result[result.length - 1].numericField);
-            result.forEach((user) => {
-                expect(user.session.length).toBeGreaterThan(0);
-            });
-        },
-        "findMany - should find many with join and where clause": async () => {
-            const users = [];
-            for (let i = 0; i < 5; i++) {
-                const user = await adapter.create({
-                    model: "user",
-                    data: {
-                        ...(await generate("user")),
-                        name: i < 2 ? `target-user-${i}` : `other-user-${i}`,
-                    },
-                    forceAllowId: true,
-                });
-                users.push(user);
-                for (let j = 0; j < 2; j++) {
-                    await adapter.create({
-                        model: "session",
-                        data: { ...(await generate("session")), userId: user.id },
-                        forceAllowId: true,
-                    });
-                }
-            }
-            const result = await adapter.findMany({
-                model: "user",
-                where: [
-                    { field: "name", value: "target-user", operator: "starts_with" },
-                ],
-                join: { session: true },
-            });
-            expect(result).toHaveLength(2);
-            result.forEach((user) => {
-                expect(user.name.startsWith("target-user")).toBe(true);
-                expect(user.session).toHaveLength(2);
-            });
-        },
-        "findMany - should find many with join, where, limit, and offset": async () => {
-            const users = [];
-            for (let i = 0; i < 10; i++) {
-                const user = await adapter.create({
-                    model: "user",
-                    data: {
-                        ...(await generate("user")),
-                        name: `target-${i.toString().padStart(2, "0")}`,
-                    },
-                    forceAllowId: true,
-                });
-                users.push(user);
-                for (let j = 0; j < 2; j++) {
-                    await adapter.create({
-                        model: "session",
-                        data: { ...(await generate("session")), userId: user.id },
-                        forceAllowId: true,
-                    });
-                }
-            }
-            const result = await adapter.findMany({
-                model: "user",
-                where: [{ field: "name", value: "target", operator: "starts_with" }],
-                join: { session: true },
-                limit: 3,
-                offset: 2,
-            });
-            expect(result).toHaveLength(3);
-            result.forEach((user) => {
-                expect(user.session).toHaveLength(2);
-            });
-        },
-        "findMany - should find many with one-to-one join": async () => {
-            await modifyBetterAuthOptions({
-                plugins: [
-                    {
-                        id: "one-to-one-test",
-                        schema: {
-                            oneToOneTable: {
-                                fields: {
-                                    oneToOne: {
-                                        type: "string",
-                                        required: true,
-                                        references: { field: "id", model: "user" },
-                                        unique: true,
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ],
-            }, true);
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            const oneToOneRecords = [];
-            for (const user of users) {
-                const record = await adapter.create({
-                    model: "oneToOneTable",
-                    data: { oneToOne: user.id },
-                });
-                oneToOneRecords.push(record);
-            }
-            const result = await adapter.findMany({
-                model: "user",
-                join: { oneToOneTable: true },
-            });
-            const resultsWithJoin = result.filter((r) => r.oneToOneTable);
-            expect(resultsWithJoin).toHaveLength(3);
-            resultsWithJoin.forEach((user) => {
-                expect(user.oneToOneTable).toBeDefined();
-                expect(user.oneToOneTable.oneToOne).toBe(user.id);
-            });
-        },
-        "findMany - should find many with both one-to-one and one-to-many joins": async () => {
-            await modifyBetterAuthOptions({
-                plugins: [
-                    {
-                        id: "one-to-one-test",
-                        schema: {
-                            oneToOneTable: {
-                                fields: {
-                                    oneToOne: {
-                                        type: "string",
-                                        required: true,
-                                        references: { field: "id", model: "user" },
-                                        unique: true,
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ],
-            }, true);
-            const users = (await insertRandom("user", 2)).map((x) => x[0]);
-            for (const user of users) {
-                await adapter.create({
-                    model: "oneToOneTable",
-                    data: { oneToOne: user.id },
-                });
-                for (let i = 0; i < 2; i++) {
-                    await adapter.create({
-                        model: "session",
-                        data: { ...(await generate("session")), userId: user.id },
-                        forceAllowId: true,
-                    });
-                }
-            }
-            const result = await adapter.findMany({
-                model: "user",
-                join: { oneToOneTable: true, session: true },
-            });
-            const resultsWithBothJoins = result.filter((r) => r.oneToOneTable && r.session?.length > 0);
-            expect(resultsWithBothJoins.length).toBeGreaterThanOrEqual(2);
-            resultsWithBothJoins.forEach((user) => {
-                expect(user.oneToOneTable).toBeDefined();
-                expect(Array.isArray(user.session)).toBe(true);
-                expect(user.session.length).toBeGreaterThan(0);
-            });
-        },
-        "findMany - should return an empty array when no models are found": async () => {
-            const options = getBetterAuthOptions();
-            const useUUIDs = options.advanced?.database?.generateId === "uuid";
-            const result = await adapter.findMany({
-                model: "user",
-                where: [
-                    { field: "id", value: useUUIDs ? crypto.randomUUID() : "100000" },
-                ],
-            });
-            expect(result).toEqual([]);
-        },
-        "findMany - should return empty array when base records don't exist with joins": async () => {
-            await modifyBetterAuthOptions({
-                plugins: [
-                    {
-                        id: "one-to-one-test",
-                        schema: {
-                            oneToOneTable: {
-                                fields: {
-                                    oneToOne: {
-                                        type: "string",
-                                        required: true,
-                                        references: { field: "id", model: "user" },
-                                        unique: true,
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ],
-            }, true);
-            const options = getBetterAuthOptions();
-            const useUUIDs = options.advanced?.database?.generateId === "uuid";
-            const result = await adapter.findMany({
-                model: "user",
-                where: [
-                    { field: "id", value: useUUIDs ? crypto.randomUUID() : "100000" },
-                ],
-                join: { session: true, account: true, oneToOneTable: true },
-            });
-            expect(result).toEqual([]);
-        },
-        "findMany - should find many models with starts_with operator": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            const result = await adapter.findMany({
-                model: "user",
-                where: [{ field: "name", value: "user", operator: "starts_with" }],
-            });
-            expect(sortModels(result)).toEqual(sortModels(users));
-        },
-        "findMany - starts_with should not interpret regex patterns": async () => {
-            // Create a user whose name literally starts with the regex-like prefix
-            const userTemplate = await generate("user");
-            const literalRegexUser = await adapter.create({
-                model: "user",
-                data: {
-                    ...userTemplate,
-                    name: ".*danger",
-                },
-                forceAllowId: true,
-            });
-            // Also create some normal users that do NOT start with ".*"
-            await insertRandom("user", 3);
-            const result = await adapter.findMany({
-                model: "user",
-                where: [{ field: "name", value: ".*", operator: "starts_with" }],
-            });
-            // Should only match the literal ".*" prefix, not treat it as a regex matching everything
-            expect(result.length).toBe(1);
-            expect(result[0].id).toBe(literalRegexUser.id);
-            expect(result[0].name.startsWith(".*")).toBe(true);
-        },
-        "findMany - ends_with should not interpret regex patterns": async () => {
-            // Create a user whose name literally ends with the regex-like suffix
-            const userTemplate = await generate("user");
-            const literalRegexUser = await adapter.create({
-                model: "user",
-                data: {
-                    ...userTemplate,
-                    name: "danger.*",
-                },
-                forceAllowId: true,
-            });
-            // Also create some normal users that do NOT end with ".*"
-            await insertRandom("user", 3);
-            const result = await adapter.findMany({
-                model: "user",
-                where: [{ field: "name", value: ".*", operator: "ends_with" }],
-            });
-            // Should only match the literal ".*" suffix, not treat it as a regex matching everything
-            expect(result.length).toBe(1);
-            expect(result[0].id).toBe(literalRegexUser.id);
-            expect(result[0].name.endsWith(".*")).toBe(true);
-        },
-        "findMany - contains should not interpret regex patterns": async () => {
-            // Create a user whose name literally contains the regex-like pattern
-            const userTemplate = await generate("user");
-            const literalRegexUser = await adapter.create({
-                model: "user",
-                data: {
-                    ...userTemplate,
-                    name: "prefix-.*-suffix",
-                },
-                forceAllowId: true,
-            });
-            // Also create some normal users that do NOT contain ".*"
-            await insertRandom("user", 3);
-            const result = await adapter.findMany({
-                model: "user",
-                where: [{ field: "name", value: ".*", operator: "contains" }],
-            });
-            // Should only match the literal substring ".*", not treat it as a regex matching everything
-            expect(result.length).toBe(1);
-            expect(result[0].id).toBe(literalRegexUser.id);
-            expect(result[0].name.includes(".*")).toBe(true);
-        },
-        "findMany - should find many models with ends_with operator": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            for (const user of users) {
-                const res = await adapter.update({
-                    model: "user",
-                    where: [{ field: "id", value: user.id }],
-                    update: { name: user.name.toLowerCase() }, // make name lowercase
-                });
-                if (!res)
-                    throw new Error("No result");
-                const u = users.find((u) => u.id === user.id);
-                u.name = res.name;
-                u.updatedAt = res.updatedAt;
-            }
-            const ends_with = users[0].name.slice(-1);
-            const result = await adapter.findMany({
-                model: "user",
-                where: [
-                    {
-                        field: "name",
-                        value: ends_with,
-                        operator: "ends_with",
-                    },
-                ],
-            });
-            const expectedResult = sortModels(users.filter((user) => user.name.endsWith(ends_with)));
-            if (result.length !== expectedResult.length) {
-                console.log(`Result length: ${result.length}`);
-                console.log(sortModels(result));
-                console.log("--------------------------------");
-                console.log(`Expected result length: ${expectedResult.length} - key: ${JSON.stringify(ends_with)}`);
-                console.log(expectedResult);
-            }
-            expect(sortModels(result)).toEqual(expectedResult);
-        },
-        "findMany - should find many models with contains operator": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            // if this check fails, the test will fail.
-            // insertRandom needs to generate emails that contain `@email.com`
-            expect(users[0].email).toContain("@email.com");
-            const result = await adapter.findMany({
-                model: "user",
-                where: [
-                    {
-                        field: "email",
-                        value: "mail", // all emails contains `@email.com` from `insertRandom`
-                        operator: "contains",
-                    },
-                ],
-            });
-            expect(sortModels(result)).toEqual(sortModels(users));
-        },
-        "findMany - should handle multiple where conditions with different operators": async () => {
-            const testData = [
-                { name: "john doe", email: "john@example.com" },
-                { name: "jane smith", email: "jane@gmail.com" },
-            ];
-            const createdUsers = [];
-            for (const data of testData) {
-                const user = await adapter.create({
-                    model: "user",
-                    data: {
-                        ...generate("user"),
-                        ...data,
-                    },
-                    forceAllowId: true,
-                });
-                createdUsers.push(user);
-            }
-            const result = await adapter.findMany({
-                model: "user",
-                where: [
-                    {
-                        field: "email",
-                        value: "john@example.com",
-                        operator: "eq",
-                        connector: "AND",
-                    },
-                    {
-                        field: "name",
-                        value: "john",
-                        operator: "contains",
-                        connector: "AND",
-                    },
-                ],
-            });
-            expect(result.length).toBe(1);
-            expect(result[0].email).toBe("john@example.com");
-            expect(result[0].name).toBe("john doe");
-            const result2 = await adapter.findMany({
-                model: "user",
-                where: [
-                    {
-                        field: "email",
-                        value: "gmail",
-                        operator: "contains",
-                        connector: "AND",
-                    },
-                    {
-                        field: "name",
-                        value: "jane",
-                        operator: "contains",
-                        connector: "AND",
-                    },
-                ],
-            });
-            expect(result2.length).toBe(1);
-            expect(result2[0].email).toBe("jane@gmail.com");
-            expect(result2[0].name).toBe("jane smith");
-            const result3 = await adapter.findMany({
-                model: "user",
-                where: [
-                    {
-                        field: "email",
-                        value: "john",
-                        operator: "starts_with",
-                        connector: "AND",
-                    },
-                    {
-                        field: "name",
-                        value: "john",
-                        operator: "contains",
-                        connector: "AND",
-                    },
-                ],
-            });
-            expect(result3.length).toBe(1);
-            expect(result3[0].email).toBe("john@example.com");
-            expect(result3[0].name).toBe("john doe");
-        },
-        "findMany - should find many models with contains operator (using symbol)": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            const result = await adapter.findMany({
-                model: "user",
-                where: [{ field: "email", value: "@", operator: "contains" }],
-            });
-            expect(sortModels(result)).toEqual(sortModels(users));
-        },
-        "findMany - should find many models with eq operator": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            const result = await adapter.findMany({
-                model: "user",
-                where: [{ field: "email", value: users[0].email, operator: "eq" }],
-            });
-            expect(sortModels(result)).toEqual(sortModels([users[0]]));
-        },
-        "findMany - should find many models with ne operator": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            const result = await adapter.findMany({
-                model: "user",
-                where: [{ field: "email", value: users[0].email, operator: "ne" }],
-            });
-            expect(sortModels(result)).toEqual(sortModels(users.slice(1)));
-        },
-        "findMany - should find many models with gt operator": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            const oldestUser = users.sort((a, b) => a.createdAt - b.createdAt)[0];
-            const result = await adapter.findMany({
-                model: "user",
-                where: [
-                    {
-                        field: "createdAt",
-                        value: oldestUser.createdAt,
-                        operator: "gt",
-                    },
-                ],
-            });
-            const expectedResult = sortModels(users.filter((user) => user.createdAt > oldestUser.createdAt));
-            expect(result.length).not.toBe(0);
-            expect(sortModels(result)).toEqual(expectedResult);
-        },
-        "findMany - should find many models with gte operator": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            const oldestUser = users.sort((a, b) => b.createdAt - a.createdAt)[0];
-            const result = await adapter.findMany({
-                model: "user",
-                where: [
-                    {
-                        field: "createdAt",
-                        value: oldestUser.createdAt,
-                        operator: "gte",
-                    },
-                ],
-            });
-            const expectedResult = users.filter((user) => user.createdAt >= oldestUser.createdAt);
-            expect(result.length).not.toBe(0);
-            expect(sortModels(result)).toEqual(sortModels(expectedResult));
-        },
-        "findMany - should find many models with lte operator": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            const result = await adapter.findMany({
-                model: "user",
-                where: [
-                    { field: "createdAt", value: users[0].createdAt, operator: "lte" },
-                ],
-            });
-            const expectedResult = users.filter((user) => user.createdAt <= users[0].createdAt);
-            expect(sortModels(result)).toEqual(sortModels(expectedResult));
-        },
-        "findMany - should find many models with lt operator": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            const result = await adapter.findMany({
-                model: "user",
-                where: [
-                    { field: "createdAt", value: users[0].createdAt, operator: "lt" },
-                ],
-            });
-            const expectedResult = users.filter((user) => user.createdAt < users[0].createdAt);
-            expect(sortModels(result)).toEqual(sortModels(expectedResult));
-        },
-        "findMany - should find many models with in operator": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            const result = await adapter.findMany({
-                model: "user",
-                where: [
-                    {
-                        field: "id",
-                        value: [users[0].id, users[1].id],
-                        operator: "in",
-                    },
-                ],
-            });
-            const expectedResult = users.filter((user) => user.id === users[0].id || user.id === users[1].id);
-            expect(sortModels(result)).toEqual(sortModels(expectedResult));
-        },
-        "findMany - should find many models with not_in operator": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            const result = await adapter.findMany({
-                model: "user",
-                where: [
-                    {
-                        field: "id",
-                        value: [users[0].id, users[1].id],
-                        operator: "not_in",
-                    },
-                ],
-            });
-            expect(sortModels(result)).toEqual([users[2]]);
-        },
-        "findMany - should find many models with sortBy": async () => {
-            let n = -1;
-            await modifyBetterAuthOptions({
-                user: {
-                    additionalFields: {
-                        numericField: {
-                            type: "number",
-                            defaultValue() {
-                                return n++;
-                            },
-                        },
-                    },
-                },
-            }, true);
-            const users = (await insertRandom("user", 5)).map((x) => x[0]);
-            const result = await adapter.findMany({
-                model: "user",
-                sortBy: { field: "numericField", direction: "asc" },
-            });
-            const expectedResult = users
-                .map((x) => x.numericField)
-                .sort((a, b) => a - b);
-            try {
-                expect(result.map((x) => x.numericField)).toEqual(expectedResult);
-            }
-            catch (error) {
-                console.log(`--------------------------------`);
-                console.log(`result:`);
-                console.log(result.map((x) => x.id));
-                console.log(`expected result:`);
-                console.log(expectedResult);
-                console.log(`--------------------------------`);
-                throw error;
-            }
-            const options = getBetterAuthOptions();
-            if (options.advanced?.database?.generateId === "serial") {
-                expect(Number(users[0].id)).not.toBeNaN();
-            }
-        },
-        "findMany - should find many models with limit": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            const result = await adapter.findMany({
-                model: "user",
-                limit: 2,
-            });
-            expect(result.length).toEqual(2);
-            expect(users.find((x) => x.id === result[0].id)).not.toBeNull();
-        },
-        "findMany - should find many models with offset": async () => {
-            // Note: The returned rows are ordered in no particular order
-            // This is because databases return rows in whatever order is fastest for the query.
-            const count = 10;
-            await insertRandom("user", count);
-            const result = await adapter.findMany({
-                model: "user",
-                offset: 2,
-            });
-            expect(result.length).toEqual(count - 2);
-        },
-        "findMany - should find many models with limit and offset": async () => {
-            // Note: The returned rows are ordered in no particular order
-            // This is because databases return rows in whatever order is fastest for the query.
-            const count = 5;
-            await insertRandom("user", count);
-            const result = await adapter.findMany({
-                model: "user",
-                limit: 2,
-                offset: 2,
-            });
-            expect(result.length).toEqual(2);
-            expect(result).toBeInstanceOf(Array);
-            result.forEach((user) => {
-                expect(user).toHaveProperty("id");
-                expect(user).toHaveProperty("name");
-                expect(user).toHaveProperty("email");
-            });
-        },
-        "findMany - should find many models with sortBy and offset": async () => {
-            let n = -1;
-            await modifyBetterAuthOptions({
-                user: {
-                    additionalFields: {
-                        numericField: {
-                            type: "number",
-                            defaultValue() {
-                                return n++;
-                            },
-                        },
-                    },
-                },
-            }, true);
-            const users = (await insertRandom("user", 5)).map((x) => x[0]);
-            const result = await adapter.findMany({
-                model: "user",
-                sortBy: { field: "numericField", direction: "asc" },
-                offset: 2,
-            });
-            expect(result).toHaveLength(3);
-            expect(result).toEqual(users.sort((a, b) => a.numericField - b.numericField).slice(2));
-        },
-        "findMany - should find many models with sortBy and limit": async () => {
-            let n = -1;
-            await modifyBetterAuthOptions({
-                user: {
-                    additionalFields: {
-                        numericField: {
-                            type: "number",
-                            defaultValue() {
-                                return n++;
-                            },
-                        },
-                    },
-                },
-            }, true);
-            const users = (await insertRandom("user", 5)).map((x) => x[0]);
-            const result = await adapter.findMany({
-                model: "user",
-                sortBy: { field: "numericField", direction: "asc" },
-                limit: 2,
-            });
-            expect(result).toEqual(users.sort((a, b) => a.numericField - b.numericField).slice(0, 2));
-        },
-        "findMany - should find many models with sortBy and limit and offset": async () => {
-            let n = -1;
-            await modifyBetterAuthOptions({
-                user: {
-                    additionalFields: {
-                        numericField: {
-                            type: "number",
-                            defaultValue() {
-                                return n++;
-                            },
-                        },
-                    },
-                },
-            }, true);
-            const users = (await insertRandom("user", 5)).map((x) => x[0]);
-            const result = await adapter.findMany({
-                model: "user",
-                sortBy: { field: "numericField", direction: "asc" },
-                limit: 2,
-                offset: 2,
-            });
-            expect(result.length).toBe(2);
-            expect(result).toEqual(users.sort((a, b) => a.numericField - b.numericField).slice(2, 4));
-        },
-        "findMany - should find many models with sortBy and limit and offset and where": async () => {
-            let n = -1;
-            await modifyBetterAuthOptions({
-                user: {
-                    additionalFields: {
-                        numericField: {
-                            type: "number",
-                            defaultValue() {
-                                return n++;
-                            },
-                        },
-                    },
-                },
-            }, true);
-            const users = (await insertRandom("user", 10)).map((x) => x[0]);
-            // update the last three users to end with "last"
-            let i = -1;
-            for (const user of users) {
-                i++;
-                if (i < 5)
-                    continue;
-                const result = await adapter.update({
-                    model: "user",
-                    where: [{ field: "id", value: user.id }],
-                    update: { name: user.name + "-last" },
-                });
-                if (!result)
-                    throw new Error("No result");
-                users[i].name = result.name;
-                users[i].updatedAt = result.updatedAt;
-            }
-            const result = await adapter.findMany({
-                model: "user",
-                sortBy: { field: "numericField", direction: "asc" },
-                limit: 2,
-                offset: 2,
-                where: [{ field: "name", value: "last", operator: "ends_with" }],
-            });
-            // Order of operation for most DBs:
-            // FROM → WHERE → SORT BY → OFFSET → LIMIT
-            let expectedResult = [];
-            expectedResult = users
-                .filter((user) => user.name.endsWith("last"))
-                .sort((a, b) => a.numericField - b.numericField)
-                .slice(2, 4);
-            try {
-                expect(result.length).toBe(2);
-                expect(result).toEqual(expectedResult);
-            }
-            catch (error) {
-                console.log(`--------------------------------`);
-                console.log(`results:`);
-                console.log(result.map((x) => x.id));
-                console.log(`expected results, sorted:`);
-                console.log(users
-                    .filter((x) => x.name.toString().endsWith("last"))
-                    .map((x) => x.numericField)
-                    .sort((a, b) => a - b));
-                console.log(`expected results, sorted + offset:`);
-                console.log(users
-                    .filter((x) => x.name.toString().endsWith("last"))
-                    .map((x) => x.numericField)
-                    .sort((a, b) => a - b)
-                    .slice(2, 4));
-                console.log(`--------------------------------`);
-                console.log("FAIL", error);
-                console.log(`--------------------------------`);
-                throw error;
-            }
-        },
-        "update - should update a model": async () => {
-            const [user] = await insertRandom("user");
-            const result = await adapter.update({
-                model: "user",
-                where: [{ field: "id", value: user.id }],
-                update: { name: "test-name" },
-            });
-            const expectedResult = {
-                ...user,
-                name: "test-name",
-            };
-            // because of `onUpdate` hook, the updatedAt field will be different
-            result.updatedAt = user.updatedAt;
-            expect(result).toEqual(expectedResult);
-            const findResult = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: user.id }],
-            });
-            // because of `onUpdate` hook, the updatedAt field will be different
-            findResult.updatedAt = user.updatedAt;
-            expect(findResult).toEqual(expectedResult);
-        },
-        "updateMany - should update all models when where is empty": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            await adapter.updateMany({
-                model: "user",
-                where: [],
-                update: { name: "test-name" },
-            });
-            const result = await adapter.findMany({
-                model: "user",
-            });
-            expect(sortModels(result)).toEqual(sortModels(users).map((user, i) => ({
-                ...user,
-                name: "test-name",
-                updatedAt: sortModels(result)[i].updatedAt,
-            })));
-        },
-        "updateMany - should update many models with a specific where": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            await adapter.updateMany({
-                model: "user",
-                where: [{ field: "id", value: users[0].id }],
-                update: { name: "test-name" },
-            });
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: users[0].id }],
-            });
-            expect(result).toEqual({
-                ...users[0],
-                name: "test-name",
-                updatedAt: result.updatedAt,
-            });
-        },
-        "updateMany - should update many models with a multiple where": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            await adapter.updateMany({
-                model: "user",
-                where: [
-                    { field: "id", value: users[0].id, connector: "OR" },
-                    { field: "id", value: users[1].id, connector: "OR" },
-                ],
-                update: { name: "test-name" },
-            });
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: users[0].id }],
-            });
-            expect(result).toEqual({
-                ...users[0],
-                name: "test-name",
-                updatedAt: result.updatedAt,
-            });
-        },
-        "delete - should delete a model": async () => {
-            const [user] = await insertRandom("user");
-            await adapter.delete({
-                model: "user",
-                where: [{ field: "id", value: user.id }],
-            });
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: user.id }],
-            });
-            expect(result).toBeNull();
-        },
-        "delete - should not throw on record not found": async () => {
-            const options = getBetterAuthOptions();
-            const useUUIDs = options.advanced?.database?.generateId === "uuid";
-            await expect(adapter.delete({
-                model: "user",
-                where: [
-                    { field: "id", value: useUUIDs ? crypto.randomUUID() : "100000" },
-                ],
-            })).resolves.not.toThrow();
-        },
-        /**
-         * @see https://github.com/better-auth/better-auth/issues/8313
-         */
-        "delete - should delete by non-unique field": async () => {
-            const [verification] = await insertRandom("verification");
-            await adapter.delete({
-                model: "verification",
-                where: [{ field: "identifier", value: verification.identifier }],
-            });
-            const result = await adapter.findOne({
-                model: "verification",
-                where: [{ field: "identifier", value: verification.identifier }],
-            });
-            expect(result).toBeNull();
-        },
-        "deleteMany - should delete many models": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            await adapter.deleteMany({
-                model: "user",
-                where: [
-                    { field: "id", value: users[0].id, connector: "OR" },
-                    { field: "id", value: users[1].id, connector: "OR" },
-                ],
-            });
-            const result = await adapter.findMany({
-                model: "user",
-            });
-            expect(sortModels(result)).toEqual(sortModels(users.slice(2)));
-        },
-        "deleteMany - starts_with should not interpret regex patterns": async () => {
-            // Create a user whose name literally starts with the regex-like prefix
-            const userTemplate = await generate("user");
-            const literalRegexUser = await adapter.create({
-                model: "user",
-                data: {
-                    ...userTemplate,
-                    name: ".*danger",
-                },
-                forceAllowId: true,
-            });
-            // Also create some normal users that do NOT start with ".*"
-            const normalUsers = (await insertRandom("user", 3)).map((x) => x[0]);
-            await adapter.deleteMany({
-                model: "user",
-                where: [{ field: "name", value: ".*", operator: "starts_with" }],
-            });
-            // The literal ".*danger" user should be deleted
-            const deleted = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: literalRegexUser.id }],
-            });
-            expect(deleted).toBeNull();
-            // Normal users should remain
-            for (const user of normalUsers) {
-                const stillThere = await adapter.findOne({
-                    model: "user",
-                    where: [{ field: "id", value: user.id }],
-                });
-                expect(stillThere).not.toBeNull();
-            }
-        },
-        "deleteMany - ends_with should not interpret regex patterns": async () => {
-            // Create a user whose name literally ends with the regex-like suffix
-            const userTemplate = await generate("user");
-            const literalRegexUser = await adapter.create({
-                model: "user",
-                data: {
-                    ...userTemplate,
-                    name: "danger.*",
-                },
-                forceAllowId: true,
-            });
-            const normalUsers = (await insertRandom("user", 3)).map((x) => x[0]);
-            await adapter.deleteMany({
-                model: "user",
-                where: [{ field: "name", value: ".*", operator: "ends_with" }],
-            });
-            const deleted = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: literalRegexUser.id }],
-            });
-            expect(deleted).toBeNull();
-            for (const user of normalUsers) {
-                const stillThere = await adapter.findOne({
-                    model: "user",
-                    where: [{ field: "id", value: user.id }],
-                });
-                expect(stillThere).not.toBeNull();
-            }
-        },
-        "deleteMany - contains should not interpret regex patterns": async () => {
-            // Create a user whose name literally contains the regex-like pattern
-            const userTemplate = await generate("user");
-            const literalRegexUser = await adapter.create({
-                model: "user",
-                data: {
-                    ...userTemplate,
-                    name: "prefix-.*-suffix",
-                },
-                forceAllowId: true,
-            });
-            const normalUsers = (await insertRandom("user", 3)).map((x) => x[0]);
-            await adapter.deleteMany({
-                model: "user",
-                where: [{ field: "name", value: ".*", operator: "contains" }],
-            });
-            const deleted = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: literalRegexUser.id }],
-            });
-            expect(deleted).toBeNull();
-            for (const user of normalUsers) {
-                const stillThere = await adapter.findOne({
-                    model: "user",
-                    where: [{ field: "id", value: user.id }],
-                });
-                expect(stillThere).not.toBeNull();
-            }
-        },
-        "deleteMany - should delete many models with numeric values": async () => {
-            let i = 0;
-            await modifyBetterAuthOptions({
-                user: {
-                    additionalFields: {
-                        numericField: {
-                            type: "number",
-                            defaultValue() {
-                                return i++;
-                            },
-                        },
-                    },
-                },
-            }, true);
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            if (!users[0] || !users[1] || !users[2]) {
-                expect(false).toBe(true);
-                throw new Error("Users not found");
-            }
-            expect(users[0].numericField).toEqual(0);
-            expect(users[1].numericField).toEqual(1);
-            expect(users[2].numericField).toEqual(2);
-            await adapter.deleteMany({
-                model: "user",
-                where: [
-                    {
-                        field: "numericField",
-                        value: users[0].numericField,
-                        operator: "gt",
-                    },
-                ],
-            });
-            const result = await adapter.findMany({
-                model: "user",
-            });
-            expect(result).toEqual([users[0]]);
-        },
-        "deleteMany - should delete many models with boolean values": async () => {
-            const users = (await insertRandom("user", 3)).map((x) => x[0]);
-            // in this test, we have 3 users, two of which have emailVerified set to true and one to false
-            // delete all that has emailVerified set to true, and expect users[1] to be the only one left
-            if (!users[0] || !users[1] || !users[2]) {
-                expect(false).toBe(true);
-                throw new Error("Users not found");
-            }
-            await adapter.updateMany({
-                model: "user",
-                where: [],
-                update: { emailVerified: true },
-            });
-            await adapter.update({
-                model: "user",
-                where: [{ field: "id", value: users[1].id }],
-                update: { emailVerified: false },
-            });
-            await adapter.deleteMany({
-                model: "user",
-                where: [{ field: "emailVerified", value: true }],
-            });
-            const result = await adapter.findMany({
-                model: "user",
-            });
-            expect(result).toHaveLength(1);
-            expect(result.find((user) => user.id === users[0]?.id)).toBeUndefined();
-            expect(result.find((user) => user.id === users[1]?.id)).toBeDefined();
-            expect(result.find((user) => user.id === users[2]?.id)).toBeUndefined();
-        },
-        "count - should count many models": async () => {
-            const users = await insertRandom("user", 15);
-            const result = await adapter.count({
-                model: "user",
-            });
-            expect(result).toEqual(users.length);
-        },
-        "count - should return 0 with no rows to count": async () => {
-            const result = await adapter.count({
-                model: "user",
-            });
-            expect(result).toEqual(0);
-        },
-        "count - should count with where clause": async () => {
-            const users = (await insertRandom("user", 15)).map((x) => x[0]);
-            const result = await adapter.count({
-                model: "user",
-                where: [
-                    { field: "id", value: users[2].id, connector: "OR" },
-                    { field: "id", value: users[3].id, connector: "OR" },
-                ],
-            });
-            expect(result).toEqual(2);
-        },
-        "update - should correctly return record when updating a field used in where clause": async () => {
-            // This tests the fix for MySQL where updating a field that's in the where clause
-            // would previously fail to find the record using the old value
-            const [user] = await insertRandom("user");
-            const originalEmail = user.email;
-            // Update the email, using the old email in the where clause
-            const result = await adapter.update({
-                model: "user",
-                where: [{ field: "email", value: originalEmail }],
-                update: { email: "newemail@example.com" },
-            });
-            // Should return the updated record with the new email
-            expect(result).toBeDefined();
-            expect(result.email).toBe("newemail@example.com");
-            expect(result.id).toBe(user.id);
-            // Verify the update persisted by finding with new email
-            const foundUser = await adapter.findOne({
-                model: "user",
-                where: [{ field: "email", value: "newemail@example.com" }],
-            });
-            expect(foundUser).toBeDefined();
-            expect(foundUser.id).toBe(user.id);
-            // Old email should not exist
-            const oldUser = await adapter.findOne({
-                model: "user",
-                where: [{ field: "email", value: originalEmail }],
-            });
-            expect(oldUser).toBeNull();
-        },
-        "update - should handle updating multiple fields including where clause field": async () => {
-            const [user] = await insertRandom("user");
-            const originalEmail = user.email;
-            const result = await adapter.update({
-                model: "user",
-                where: [{ field: "email", value: originalEmail }],
-                update: {
-                    email: "updated@example.com",
-                    name: "Updated Name",
-                    emailVerified: true,
-                },
-            });
-            expect(result.email).toBe("updated@example.com");
-            expect(result.name).toBe("Updated Name");
-            expect(result.emailVerified).toBe(true);
-            expect(result.id).toBe(user.id);
-        },
-        "update - should work when updated field is not in where clause": async () => {
-            // Regression test: ensure normal updates still work
-            const [user] = await insertRandom("user");
-            const result = await adapter.update({
-                model: "user",
-                where: [{ field: "email", value: user.email }],
-                update: { name: "Updated Name Only" },
-            });
-            expect(result.name).toBe("Updated Name Only");
-            expect(result.email).toBe(user.email); // Should remain unchanged
-            expect(result.id).toBe(user.id);
-        },
-        "findOne - backwards join should only return single record not array": async () => {
-            const user = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            const session = await adapter.create({
-                model: "session",
-                data: { ...(await generate("session")), userId: user.id },
-                forceAllowId: true,
-            });
-            const result = await adapter.findOne({
-                model: "session",
-                where: [{ field: "id", value: session.id }],
-                join: { user: true },
-            });
-            expect(result?.user).toBeDefined();
-            expect(Array.isArray(result?.user)).toBe(false);
-            expect(result?.user?.id).toBe(user.id);
-        },
-        "findMany - backwards join should only return single record not array": async () => {
-            const users = (await insertRandom("user", 2)).map((x) => x[0]);
-            const sessions = [];
-            for (const user of users) {
-                const session = await adapter.create({
-                    model: "session",
-                    data: { ...(await generate("session")), userId: user.id },
-                    forceAllowId: true,
-                });
-                sessions.push(session);
-            }
-            const result = await adapter.findMany({
-                model: "session",
-                join: { user: true },
-            });
-            result.forEach((session) => {
-                expect(session.user).toBeDefined();
-                expect(Array.isArray(session.user)).toBe(false);
-                expect(session.user?.id).toBeDefined();
-            });
-        },
-        "findOne - backwards join with modified field name (session base, users-table join)": async () => {
-            await modifyBetterAuthOptions({
-                user: {
-                    modelName: "user_table",
-                },
-            }, true);
-            const user = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            const session = await adapter.create({
-                model: "session",
-                data: { ...(await generate("session")), userId: user.id },
-                forceAllowId: true,
-            });
-            const result = await adapter.findOne({
-                model: "session",
-                where: [{ field: "id", value: session.id }],
-                join: { user: true },
-            });
-            expect(result).toEqual({
-                ...session,
-                user: user,
-            });
-            expect(result?.user).toBeDefined();
-            expect(Array.isArray(result?.user)).toBe(false);
-            expect(result?.user?.id).toBe(user.id);
-        },
-        "findOne - multiple joins should return result even when some joined tables have no matching rows": async () => {
-            await modifyBetterAuthOptions({
-                plugins: [organization({ teams: { enabled: true } })],
-            }, true);
-            // Create a user and organization
-            const user = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            const organizationData = await adapter.create({
-                model: "organization",
-                data: {
-                    name: "Test Organization",
-                    slug: "test-org-" + Math.random(),
-                    createdAt: new Date(),
-                },
-                forceAllowId: true,
-            });
-            // Add a member to the organization
-            await adapter.create({
-                model: "member",
-                data: {
-                    organizationId: organizationData.id,
-                    userId: user.id,
-                    role: "owner",
-                    createdAt: new Date(),
-                },
-                forceAllowId: true,
-            });
-            // Create a team for the organization
-            await adapter.create({
-                model: "team",
-                data: {
-                    name: "Test Team",
-                    organizationId: organizationData.id,
-                    createdAt: new Date(),
-                },
-                forceAllowId: true,
-            });
-            const result = await adapter.findOne({
-                model: "organization",
-                where: [{ field: "id", value: organizationData.id }],
-                join: {
-                    member: true,
-                    team: true,
-                    invitation: true,
-                },
-            });
-            expect(result).toBeDefined();
-            expect(result?.id).toBe(organizationData.id);
-            expect(result?.name).toBe("Test Organization");
-            // Verify member join worked
-            expect(Array.isArray(result?.member)).toBe(true);
-            expect(result?.member).toHaveLength(1);
-            expect(result?.member[0]?.userId).toBe(user.id);
-            expect(result?.member[0]?.role).toBe("owner");
-            // Verify team join worked
-            expect(Array.isArray(result?.team)).toBe(true);
-            expect(result?.team).toHaveLength(1);
-            expect(result?.team[0]?.name).toBe("Test Team");
-            // Verify invitation is empty array
-            expect(Array.isArray(result?.invitation)).toBe(true);
-            expect(result?.invitation).toHaveLength(0);
-        },
-        "findOne - should be able to perform a limited join": async () => {
-            const user = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            for (let i = 0; i < 5; i++) {
-                await adapter.create({
-                    model: "session",
-                    data: { ...(await generate("session")), userId: user.id },
-                    forceAllowId: true,
-                });
-            }
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: user.id }],
-                join: {
-                    session: { limit: 2 },
-                },
-            });
-            expect(result).toBeDefined();
-            expect(result?.session).toBeDefined();
-            expect(result?.session).toHaveLength(2);
-            expect(result?.session[0]?.userId).toBe(user.id);
-        },
-        "findOne - should be able to perform a complex limited join": async () => {
-            const user = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            for (let i = 0; i < 5; i++) {
-                await adapter.create({
-                    model: "session",
-                    data: { ...(await generate("session")), userId: user.id },
-                    forceAllowId: true,
-                });
-                await adapter.create({
-                    model: "account",
-                    data: { ...(await generate("account")), userId: user.id },
-                    forceAllowId: true,
-                });
-            }
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: user.id }],
-                join: {
-                    session: { limit: 2 },
-                    account: { limit: 3 },
-                },
-            });
-            expect(result).toBeDefined();
-            expect(result?.session).toBeDefined();
-            expect(result?.session).toHaveLength(2);
-            expect(result?.account).toBeDefined();
-            expect(result?.account).toHaveLength(3);
-        },
-        "findMany - should be able to perform a limited join": async () => {
-            const users = [];
-            for (let i = 0; i < 5; i++) {
-                const user = await adapter.create({
-                    model: "user",
-                    data: { ...(await generate("user")) },
-                    forceAllowId: true,
-                });
-                users.push(user);
-            }
-            const sessionsByUser = new Map();
-            for (const user of users) {
-                sessionsByUser.set(user.id, []);
-                for (let i = 0; i < 5; i++) {
-                    const session = await adapter.create({
-                        model: "session",
-                        data: { ...(await generate("session")), userId: user.id },
-                        forceAllowId: true,
-                    });
-                    sessionsByUser.get(user.id).push(session);
-                }
-            }
-            const result = await adapter.findMany({
-                model: "user",
-                join: { session: { limit: 2 } },
-            });
-            expect(result).toBeDefined();
-            expect(result).toHaveLength(5);
-            result.forEach((user) => {
-                expect(user.session).toBeDefined();
-                expect(user.session).toHaveLength(2);
-                expect(user.session[0]?.userId).toBe(user.id);
-            });
-        },
-        "findMany - should be able to perform a complex limited join": async () => {
-            const users = [];
-            const sessionsByUser = new Map();
-            const accountsByUser = new Map();
-            for (let i = 0; i < 5; i++) {
-                const user = await adapter.create({
-                    model: "user",
-                    data: { ...(await generate("user")) },
-                    forceAllowId: true,
-                });
-                users.push(user);
-                sessionsByUser.set(user.id, []);
-                accountsByUser.set(user.id, []);
-                for (let i = 0; i < 5; i++) {
-                    const session = await adapter.create({
-                        model: "session",
-                        data: { ...(await generate("session")), userId: user.id },
-                        forceAllowId: true,
-                    });
-                    sessionsByUser.get(user.id).push(session);
-                    const account = await adapter.create({
-                        model: "account",
-                        data: { ...(await generate("account")), userId: user.id },
-                        forceAllowId: true,
-                    });
-                    accountsByUser.get(user.id).push(account);
-                }
-            }
-            const result = await adapter.findMany({
-                model: "user",
-                join: {
-                    session: { limit: 2 },
-                    account: { limit: 3 },
-                },
-                limit: 2,
-                offset: 2,
-            });
-            expect(result).toBeDefined();
-            expect(result).toHaveLength(2);
-            result.forEach((user) => {
-                expect(user.session).toBeDefined();
-                expect(user.session).toHaveLength(2);
-                expect(user.session[0]?.userId).toBe(user.id);
-                expect(user.account).toBeDefined();
-                expect(user.account).toHaveLength(3);
-                expect(user.account[0]?.userId).toBe(user.id);
-            });
-        },
-        "findOne - should return null for one-to-one join when joined record doesn't exist": async () => {
-            await modifyBetterAuthOptions({
-                plugins: [
-                    {
-                        id: "one-to-one-test",
-                        schema: {
-                            oneToOneTable: {
-                                fields: {
-                                    oneToOne: {
-                                        type: "string",
-                                        required: true,
-                                        references: { field: "id", model: "user" },
-                                        unique: true,
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ],
-            }, true);
-            // Create a user without a corresponding one-to-one record
-            const user = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            const result = await adapter.findOne({
-                model: "user",
-                where: [{ field: "id", value: user.id }],
-                join: { oneToOneTable: true },
-            });
-            expect(result).toBeDefined();
-            expect(result?.id).toBe(user.id);
-            expect(result?.oneToOneTable).toBeNull();
-        },
-        "findMany - should return null for one-to-one join when joined records don't exist": async () => {
-            await modifyBetterAuthOptions({
-                plugins: [
-                    {
-                        id: "one-to-one-test",
-                        schema: {
-                            oneToOneTable: {
-                                fields: {
-                                    oneToOne: {
-                                        type: "string",
-                                        required: true,
-                                        references: { field: "id", model: "user" },
-                                        unique: true,
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ],
-            }, true);
-            // Create multiple users - some with one-to-one records, some without
-            const userWithJoin = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            const oneToOne = await adapter.create({
-                model: "oneToOneTable",
-                data: { oneToOne: userWithJoin.id },
-            });
-            const userWithoutJoin = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            const result = await adapter.findMany({
-                model: "user",
-                where: [
-                    { field: "id", value: userWithJoin.id, connector: "OR" },
-                    { field: "id", value: userWithoutJoin.id, connector: "OR" },
-                ],
-                join: { oneToOneTable: true },
-            });
-            expect(result).toBeDefined();
-            expect(result.length).toBe(2);
-            const resultWithJoin = result.find((u) => u.id === userWithJoin.id);
-            const resultWithoutJoin = result.find((u) => u.id === userWithoutJoin.id);
-            expect(resultWithJoin).toBeDefined();
-            expect(resultWithJoin?.oneToOneTable).toBeDefined();
-            expect(resultWithJoin?.oneToOneTable?.id).toBe(oneToOne.id);
-            expect(resultWithoutJoin).toBeDefined();
-            expect(resultWithoutJoin?.oneToOneTable).toBeNull();
+            expect(sortModels(result)).toEqual(sortModels(users.filter((user) => toMillis(user.createdAt) < toMillis(youngestUser.createdAt))));
         },
-        "findMany - should return empty array for one-to-many join when joined records don't exist": async () => {
-            // Create multiple users - some with sessions, some without
-            const userWithSessions = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            const session1 = await adapter.create({
-                model: "session",
-                data: { ...(await generate("session")), userId: userWithSessions.id },
-                forceAllowId: true,
-            });
-            const session2 = await adapter.create({
-                model: "session",
-                data: { ...(await generate("session")), userId: userWithSessions.id },
-                forceAllowId: true,
-            });
-            const userWithoutSessions = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
+        "findMany - should find many models with gt operator": async () => {
+            const users = (await insertRandom("user", 3)).map((entry) => entry[0]);
+            const oldestUser = users.sort((a, b) => toMillis(a.createdAt) - toMillis(b.createdAt))[0];
             const result = await adapter.findMany({
                 model: "user",
                 where: [
-                    { field: "id", value: userWithSessions.id, connector: "OR" },
-                    { field: "id", value: userWithoutSessions.id, connector: "OR" },
-                ],
-                join: { session: true },
-            });
-            expect(result).toBeDefined();
-            expect(result.length).toBe(2);
-            const resultWithSessions = result.find((u) => u.id === userWithSessions.id);
-            const resultWithoutSessions = result.find((u) => u.id === userWithoutSessions.id);
-            expect(resultWithSessions).toBeDefined();
-            expect(Array.isArray(resultWithSessions?.session)).toBe(true);
-            expect(resultWithSessions?.session).toHaveLength(2);
-            expect(resultWithSessions?.session.some((s) => s.id === session1.id)).toBe(true);
-            expect(resultWithSessions?.session.some((s) => s.id === session2.id)).toBe(true);
-            expect(resultWithoutSessions).toBeDefined();
-            expect(Array.isArray(resultWithoutSessions?.session)).toBe(true);
-            expect(resultWithoutSessions?.session).toHaveLength(0);
-        },
-        "findMany - should handle mixed joins correctly when some are missing": async () => {
-            await modifyBetterAuthOptions({
-                plugins: [
                     {
-                        id: "one-to-one-test",
-                        schema: {
-                            oneToOneTable: {
-                                fields: {
-                                    oneToOne: {
-                                        type: "string",
-                                        required: true,
-                                        references: { field: "id", model: "user" },
-                                        unique: true,
-                                    },
-                                },
-                            },
-                        },
+                        field: "createdAt",
+                        value: oldestUser.createdAt,
+                        operator: "gt",
                     },
                 ],
-            }, true);
-            // User 1: Has both one-to-one and one-to-many joins
-            const user1 = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            const oneToOne1 = await adapter.create({
-                model: "oneToOneTable",
-                data: { oneToOne: user1.id },
-            });
-            const session1 = await adapter.create({
-                model: "session",
-                data: { ...(await generate("session")), userId: user1.id },
-                forceAllowId: true,
-            });
-            // User 2: Has one-to-one but no one-to-many
-            const user2 = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            const oneToOne2 = await adapter.create({
-                model: "oneToOneTable",
-                data: { oneToOne: user2.id },
-            });
-            // User 3: Has one-to-many but no one-to-one
-            const user3 = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
-            });
-            const session3 = await adapter.create({
-                model: "session",
-                data: { ...(await generate("session")), userId: user3.id },
-                forceAllowId: true,
-            });
-            // User 4: Has neither join
-            const user4 = await adapter.create({
-                model: "user",
-                data: { ...(await generate("user")) },
-                forceAllowId: true,
             });
+            const expectedResult = sortModels(users.filter((user) => toMillis(user.createdAt) > toMillis(oldestUser.createdAt)));
+            expect(result.length).not.toBe(0);
+            expect(sortModels(result)).toEqual(expectedResult);
+        },
+        "findMany - should find many models with gte operator": async () => {
+            const users = (await insertRandom("user", 3)).map((entry) => entry[0]);
+            const oldestUser = users.sort((a, b) => toMillis(b.createdAt) - toMillis(a.createdAt))[0];
             const result = await adapter.findMany({
                 model: "user",
                 where: [
-                    { field: "id", value: user1.id, connector: "OR" },
-                    { field: "id", value: user2.id, connector: "OR" },
-                    { field: "id", value: user3.id, connector: "OR" },
-                    { field: "id", value: user4.id, connector: "OR" },
-                ],
-                join: { oneToOneTable: true, session: true },
-            });
-            expect(result).toBeDefined();
-            expect(result.length).toBe(4);
-            // User 1: Has both
-            const result1 = result.find((u) => u.id === user1.id);
-            expect(result1).toBeDefined();
-            expect(result1?.oneToOneTable).toBeDefined();
-            expect(result1?.oneToOneTable?.id).toBe(oneToOne1.id);
-            expect(Array.isArray(result1?.session)).toBe(true);
-            expect(result1?.session).toHaveLength(1);
-            expect(result1?.session[0]?.id).toBe(session1.id);
-            // User 2: Has one-to-one, no one-to-many
-            const result2 = result.find((u) => u.id === user2.id);
-            expect(result2).toBeDefined();
-            expect(result2?.oneToOneTable).toBeDefined();
-            expect(result2?.oneToOneTable?.id).toBe(oneToOne2.id);
-            expect(Array.isArray(result2?.session)).toBe(true);
-            expect(result2?.session).toHaveLength(0);
-            // User 3: Has one-to-many, no one-to-one
-            const result3 = result.find((u) => u.id === user3.id);
-            expect(result3).toBeDefined();
-            expect(result3?.oneToOneTable).toBeNull();
-            expect(Array.isArray(result3?.session)).toBe(true);
-            expect(result3?.session).toHaveLength(1);
-            expect(result3?.session[0]?.id).toBe(session3.id);
-            // User 4: Has neither
-            const result4 = result.find((u) => u.id === user4.id);
-            expect(result4).toBeDefined();
-            expect(result4?.oneToOneTable).toBeNull();
-            expect(Array.isArray(result4?.session)).toBe(true);
-            expect(result4?.session).toHaveLength(0);
-        },
-        "create - should support arrays": {
-            migrateBetterAuth: {
-                plugins: [
-                    {
-                        id: "string-arrays-test",
-                        schema: {
-                            testModel: {
-                                fields: {
-                                    stringArray: {
-                                        type: "string[]",
-                                        required: true,
-                                    },
-                                    numberArray: {
-                                        type: "number[]",
-                                        required: true,
-                                    },
-                                },
-                            },
-                        },
-                    },
-                ],
-            },
-            test: async () => {
-                const result = await adapter.create({
-                    model: "testModel",
-                    data: { stringArray: ["1", "2", "3"], numberArray: [1, 2, 3] },
-                });
-                expect(result.stringArray).toEqual(["1", "2", "3"]);
-                expect(result.numberArray).toEqual([1, 2, 3]);
-                const findResult = await adapter.findOne({
-                    model: "testModel",
-                    where: [{ field: "id", value: result.id }],
-                });
-                expect(findResult).toEqual(result);
-                expect(findResult?.stringArray).toEqual(["1", "2", "3"]);
-                expect(findResult?.numberArray).toEqual([1, 2, 3]);
-            },
-        },
-        "create - should support json": {
-            migrateBetterAuth: {
-                plugins: [
                     {
-                        id: "json-test",
-                        schema: {
-                            testModel: {
-                                fields: {
-                                    json: {
-                                        type: "json",
-                                        required: true,
-                                    },
-                                },
-                            },
-                        },
+                        field: "createdAt",
+                        value: oldestUser.createdAt,
+                        operator: "gte",
                     },
                 ],
-            },
-            test: async () => {
-                const result = await adapter.create({
-                    model: "testModel",
-                    data: { json: { foo: "bar" } },
-                });
-                expect(result.json).toEqual({ foo: "bar" });
-                const findResult = await adapter.findOne({
-                    model: "testModel",
-                    where: [{ field: "id", value: result.id }],
-                });
-                expect(findResult).toEqual(result);
-                expect(findResult?.json).toEqual({ foo: "bar" });
-                console.log(findResult);
-            },
-        },
-        "update - should support multiple where conditions under AND connector with unique field": async () => {
-            // This test is specific to Prisma where unique fields must be at root level,
-            // not nested in AND arrays (which is what we do by default)
-            const [user] = await insertRandom("user");
-            const result = await adapter.update({
-                model: "user",
-                where: [
-                    { field: "email", value: user.email },
-                    { field: "id", value: user.id },
-                ],
-                update: { name: "Updated Name" },
             });
-            expect(result).toBeDefined();
-            expect(result.name).toBe("Updated Name");
-            expect(result.email).toBe(user.email);
-            expect(result.id).toBe(user.id);
+            const expectedResult = users.filter((user) => toMillis(user.createdAt) >= toMillis(oldestUser.createdAt));
+            expect(result.length).not.toBe(0);
+            expect(sortModels(result)).toEqual(sortModels(expectedResult));
         },
     };
 };
-const getTestKeys = () => Object.keys(getNormalTestSuiteTests({}));
-export const enableJoinTests = getTestKeys().reduce((acc, test) => {
-    if (test.includes("join")) {
-        acc[test] = false;
-    }
-    return acc;
-}, {});
 //# sourceMappingURL=basic.js.map