@convex-dev/better-auth 0.11.3 → 0.11.4

package/src/component/adapterTest.ts

@@ -13,11 +13,18 @@ import type { ComponentApi } from "./_generated/component.js";
 // globals are available through dynamic imports.
 
 const NORMAL_DISABLED_TESTS = [
+  // dynamic-schema-plugin-table/dynamic-schema-additional-fields:
+  // Convex validators are static in this harness, so runtime schema mutation
+  // tests are validated in dedicated profiles instead.
   "create - should apply default values to fields",
   "create - should return null for nullable foreign keys",
   "create - should support arrays",
   "create - should support json",
+  // convex-id-generation:
+  // Convex controls generated IDs at write time.
   "create - should use generateId if provided",
+  // offset-unsupported:
+  // Convex adapter rejects offset pagination.
   "findMany - should be able to perform a complex limited join",
   "findMany - should find many models with limit and offset",
   "findMany - should find many models with offset",
@@ -32,6 +39,8 @@ const NORMAL_DISABLED_TESTS = [
   "findMany - should return empty array when base records don't exist with joins",
   "findMany - should return null for one-to-one join when joined records don't exist",
   "findMany - should select fields with one-to-one join",
+  // profile-specific coverage:
+  // These are intentionally exercised in dedicated profile suites.
   "findOne - backwards join with modified field name (session base, users-table join)",
   "findOne - multiple joins should return result even when some joined tables have no matching rows",
   "findOne - should find a model with modified field name",
@@ -102,7 +111,9 @@ const organizationJoinsProfileApi = profileApi("adapterOrganizationJoins");
 export const runTests = action(
   async (ctx: GenericActionCtx<DataModel>, _args: EmptyObject) => {
     const testUtilsImport = "@better-auth/test-utils/adapter";
-    const { testAdapter } = await import(testUtilsImport);
+    const { testAdapter, transactionsTestSuite, uuidTestSuite } = await import(
+      testUtilsImport
+    );
     const adapterFactoryImport = "../test/adapter-factory/index.js";
     const {
       coreNormalTestSuite,
@@ -114,8 +125,6 @@ export const runTests = action(
       renameModelUserCustomTestSuite,
       renameModelUserTableTestSuite,
       multiJoinsMissingRowsTestSuite,
-      transactionsTestSuite,
-      uuidTestSuite,
       convexCustomTestSuite,
     } = await import(adapterFactoryImport);
 
@@ -264,26 +273,3 @@ export const runTests = action(
     await executeOrganizationJoinsProfile();
   }
 );
-
-// Keep this export during migration to avoid breaking generated component types.
-export const runCustomTests = action(
-  async (ctx: GenericActionCtx<DataModel>, _args: EmptyObject) => {
-    const testUtilsImport = "@better-auth/test-utils/adapter";
-    const { testAdapter } = await import(testUtilsImport);
-    const adapterFactoryImport = "../test/adapter-factory/index.js";
-    const { convexCustomTestSuite } = await import(adapterFactoryImport);
-    const authComponent = createClient<DataModel>(baseProfileApi, {
-      verbose: false,
-    });
-
-    const { execute } = await testAdapter({
-      adapter: () => {
-        return authComponent.adapter(ctx);
-      },
-      runMigrations: () => {},
-      overrideBetterAuthOptions: getOverrideBetterAuthOptions,
-      tests: [convexCustomTestSuite()],
-    });
-    await execute();
-  }
-);

package/src/test/adapter-factory/auth-flow.ts

@@ -1,170 +1,156 @@
 import type { Session, User } from "@better-auth/core/db";
-import { createTestSuite } from "@better-auth/test-utils/adapter";
+import type { createTestSuite } from "@better-auth/test-utils/adapter";
 import { setCookieToHeader } from "better-auth/cookies";
 import { expect } from "vitest";
 
 export const AUTH_FLOW_DEFAULT_BETTER_AUTH_OPTIONS = {
-	emailAndPassword: {
-		enabled: true,
-		password: {
-			hash: async (password: string) => password,
-			async verify(data: { hash: string; password: string }) {
-				return data.hash === data.password;
-			},
-		},
-	},
+  emailAndPassword: {
+    enabled: true,
+    password: {
+      hash: async (password: string) => password,
+      async verify(data: { hash: string; password: string }) {
+        return data.hash === data.password;
+      },
+    },
+  },
 };
 
 export const getAuthFlowSuiteTests = (
-	{
-		generate,
-		getAuth,
-		modifyBetterAuthOptions,
-		tryCatch,
-	}: Parameters<Parameters<typeof createTestSuite>[2]>[0],
+  {
+    generate,
+    getAuth,
+    modifyBetterAuthOptions,
+    tryCatch,
+  }: Parameters<Parameters<typeof createTestSuite>[2]>[0],
 ) => ({
-	"should successfully sign up": async () => {
-		const auth = await getAuth();
-		const user = await generate("user");
-		const result = await auth.api.signUpEmail({
-			body: {
-				email: user.email,
-				password: crypto.randomUUID(),
-				name: user.name,
-				image: user.image || "",
-			},
-		});
-		expect(result.user).toBeDefined();
-		expect(result.user.email).toBe(user.email);
-		expect(result.user.name).toBe(user.name);
-		expect(result.user.image).toBe(user.image || "");
-		expect(result.user.emailVerified).toBe(false);
-		expect(result.user.createdAt).toBeDefined();
-		expect(result.user.updatedAt).toBeDefined();
-	},
-	"should successfully sign in": async () => {
-		const auth = await getAuth();
-		const user = await generate("user");
-		const password = crypto.randomUUID();
-		const signUpResult = await auth.api.signUpEmail({
-			body: {
-				email: user.email,
-				password: password,
-				name: user.name,
-				image: user.image || "",
-			},
-		});
-		const result = await auth.api.signInEmail({
-			body: { email: user.email, password: password },
-		});
-		expect(result.user).toBeDefined();
-		expect(result.user.id).toBe(signUpResult.user.id);
-	},
-	"should successfully get session": async () => {
-		const auth = await getAuth();
-		const user = await generate("user");
-		const password = crypto.randomUUID();
-		const response = await auth.api.signUpEmail({
-			body: {
-				email: user.email,
-				password: password,
-				name: user.name,
-				image: user.image || "",
-			},
-			asResponse: true,
-		});
-		const headers = new Headers();
-		setCookieToHeader(headers)({ response });
-		const result = await auth.api.getSession({
-			headers,
-		});
-		const signUpResult = (await response.json()) as {
-			user: User;
-			session: Session;
-		};
-		signUpResult.user.createdAt = new Date(signUpResult.user.createdAt).getTime() as unknown as Date;
-		signUpResult.user.updatedAt = new Date(signUpResult.user.updatedAt).getTime() as unknown as Date;
-		expect(result?.user).toBeDefined();
-		expect(result?.user).toStrictEqual(signUpResult.user);
-		expect(result?.session).toBeDefined();
-	},
-	"should not sign in with invalid email": async () => {
-		const auth = await getAuth();
-		const user = await generate("user");
-		const { data, error } = await tryCatch(
-			auth.api.signInEmail({
-				body: { email: user.email, password: crypto.randomUUID() },
-			}),
-		);
-		expect(data).toBeNull();
-		expect(error).toBeDefined();
-	},
-	"should store and retrieve timestamps correctly across timezones": async () => {
-		using _ = recoverProcessTZ();
-		const auth = await getAuth();
-		const user = await generate("user");
-		const password = crypto.randomUUID();
-		const userSignUp = await auth.api.signUpEmail({
-			body: {
-				email: user.email,
-				password: password,
-				name: user.name,
-				image: user.image || "",
-			},
-		});
-		process.env.TZ = "Europe/London";
-		const userSignIn = await auth.api.signInEmail({
-			body: { email: user.email, password: password },
-		});
-		process.env.TZ = "America/Los_Angeles";
-		expect(userSignUp.user.createdAt).toStrictEqual(
-			userSignIn.user.createdAt,
-		);
-	},
-	"should sign up with additional fields": async () => {
-		await modifyBetterAuthOptions(
-			{ user: { additionalFields: { dateField: { type: "date" } } } },
-			true,
-		);
-		const auth = await getAuth();
-		const user = await generate("user");
-		const dateField = new Date();
-		const response = await auth.api.signUpEmail({
-			body: {
-				email: user.email,
-				name: user.name,
-				password: crypto.randomUUID(),
-				//@ts-expect-error - we are testing with additional fields
-				dateField: dateField.toISOString(), // using iso string to simulate client to server communication
-			},
-			asResponse: true,
-		});
-		const headers = new Headers();
-		setCookieToHeader(headers)({ response });
-		const result = await auth.api.getSession({
-			headers,
-		});
-		//@ts-expect-error - we are testing with additional fields
-		expect(result?.user.dateField).toStrictEqual(dateField.getTime());
-	},
+  "should successfully sign up": async () => {
+    const auth = await getAuth();
+    const user = await generate("user");
+    const result = await auth.api.signUpEmail({
+      body: {
+        email: user.email,
+        password: crypto.randomUUID(),
+        name: user.name,
+        image: user.image || "",
+      },
+    });
+    expect(result.user).toBeDefined();
+    expect(result.user.email).toBe(user.email);
+    expect(result.user.name).toBe(user.name);
+    expect(result.user.image).toBe(user.image || "");
+    expect(result.user.emailVerified).toBe(false);
+    expect(result.user.createdAt).toBeDefined();
+    expect(result.user.updatedAt).toBeDefined();
+  },
+  "should successfully sign in": async () => {
+    const auth = await getAuth();
+    const user = await generate("user");
+    const password = crypto.randomUUID();
+    const signUpResult = await auth.api.signUpEmail({
+      body: {
+        email: user.email,
+        password,
+        name: user.name,
+        image: user.image || "",
+      },
+    });
+    const result = await auth.api.signInEmail({
+      body: { email: user.email, password },
+    });
+    expect(result.user).toBeDefined();
+    expect(result.user.id).toBe(signUpResult.user.id);
+  },
+  "should successfully get session": async () => {
+    const auth = await getAuth();
+    const user = await generate("user");
+    const password = crypto.randomUUID();
+    const response = await auth.api.signUpEmail({
+      body: {
+        email: user.email,
+        password,
+        name: user.name,
+        image: user.image || "",
+      },
+      asResponse: true,
+    });
+    const headers = new Headers();
+    setCookieToHeader(headers)({ response });
+    const result = await auth.api.getSession({
+      headers,
+    });
+    const signUpResult = (await response.json()) as {
+      user: User;
+      session: Session;
+    };
+    signUpResult.user.createdAt = new Date(signUpResult.user.createdAt).getTime() as unknown as Date;
+    signUpResult.user.updatedAt = new Date(signUpResult.user.updatedAt).getTime() as unknown as Date;
+    expect(result?.user).toBeDefined();
+    expect(result?.user).toStrictEqual(signUpResult.user);
+    expect(result?.session).toBeDefined();
+  },
+  "should not sign in with invalid email": async () => {
+    const auth = await getAuth();
+    const user = await generate("user");
+    const { data, error } = await tryCatch(
+      auth.api.signInEmail({
+        body: { email: user.email, password: crypto.randomUUID() },
+      }),
+    );
+    expect(data).toBeNull();
+    expect(error).toBeDefined();
+  },
+  "should store and retrieve timestamps correctly across timezones": async () => {
+    const originalTZ = process.env.TZ;
+    try {
+      const auth = await getAuth();
+      const user = await generate("user");
+      const password = crypto.randomUUID();
+      const userSignUp = await auth.api.signUpEmail({
+        body: {
+          email: user.email,
+          password,
+          name: user.name,
+          image: user.image || "",
+        },
+      });
+      process.env.TZ = "Europe/London";
+      const userSignIn = await auth.api.signInEmail({
+        body: { email: user.email, password },
+      });
+      process.env.TZ = "America/Los_Angeles";
+      expect(userSignUp.user.createdAt).toStrictEqual(userSignIn.user.createdAt);
+    } finally {
+      if (originalTZ === undefined) {
+        delete process.env.TZ;
+      } else {
+        process.env.TZ = originalTZ;
+      }
+    }
+  },
+  "should sign up with additional fields": async () => {
+    await modifyBetterAuthOptions(
+      { user: { additionalFields: { dateField: { type: "date" } } } },
+      true,
+    );
+    const auth = await getAuth();
+    const user = await generate("user");
+    const dateField = new Date();
+    const response = await auth.api.signUpEmail({
+      body: {
+        email: user.email,
+        name: user.name,
+        password: crypto.randomUUID(),
+        //@ts-expect-error - we are testing with additional fields
+        dateField: dateField.toISOString(),
+      },
+      asResponse: true,
+    });
+    const headers = new Headers();
+    setCookieToHeader(headers)({ response });
+    const result = await auth.api.getSession({
+      headers,
+    });
+    //@ts-expect-error - we are testing with additional fields
+    expect(result?.user.dateField).toStrictEqual(dateField.getTime());
+  },
 });
-
-/**
- * This test suite tests basic authentication flow using the adapter.
- */
-export const authFlowTestSuite = createTestSuite(
-	"auth-flow",
-	{
-		defaultBetterAuthOptions: AUTH_FLOW_DEFAULT_BETTER_AUTH_OPTIONS,
-	},
-	(helpers) => getAuthFlowSuiteTests(helpers),
-);
-
-function recoverProcessTZ() {
-	const originalTZ = process.env.TZ;
-	return {
-		[Symbol.dispose]: () => {
-			process.env.TZ = originalTZ;
-		},
-	};
-}