@convex-dev/better-auth 0.10.13 → 0.11.0

package/src/test/adapter-factory/joins.ts

@@ -0,0 +1,28 @@
+import { createTestSuite } from "@better-auth/test-utils/adapter";
+import { expect } from "vitest";
+import { getNormalTestSuiteTests } from "./basic.js";
+
+export const joinsTestSuite = createTestSuite(
+	"joins",
+	{
+		defaultBetterAuthOptions: {
+			experimental: {
+				joins: true,
+			},
+		},
+		alwaysMigrate: true,
+		prefixTests: "joins",
+	},
+	(helpers) => {
+		const { "create - should use generateId if provided": _, ...normalTests } =
+			getNormalTestSuiteTests({ ...helpers });
+
+		return {
+			"init - tests": async () => {
+				const opts = helpers.getBetterAuthOptions();
+				expect(opts.experimental?.joins).toBe(true);
+			},
+			...normalTests,
+		};
+	},
+);

package/src/test/adapter-factory/number-id.ts

@@ -0,0 +1,45 @@
+import { createTestSuite } from "@better-auth/test-utils/adapter";
+import type { User } from "better-auth/types";
+import { expect } from "vitest";
+import { getNormalTestSuiteTests } from "./basic.js";
+
+export const numberIdTestSuite = createTestSuite(
+	"number-id",
+	{
+		defaultBetterAuthOptions: {
+			advanced: {
+				database: {
+					generateId: "serial",
+				},
+			},
+		},
+		alwaysMigrate: true,
+		prefixTests: "number-id",
+	},
+	(helpers) => {
+		const { "create - should use generateId if provided": _, ...normalTests } =
+			getNormalTestSuiteTests({ ...helpers });
+
+		return {
+			"init - tests": async () => {
+				const opts = helpers.getBetterAuthOptions();
+				expect(
+					(opts.advanced?.database as any)?.useNumberId ||
+						opts.advanced?.database?.generateId === "serial",
+				).toBe(true);
+			},
+			"create - should return a number id": async () => {
+				const user = await helpers.generate("user");
+				const res = await helpers.adapter.create<User>({
+					model: "user",
+					data: user,
+					forceAllowId: true,
+				});
+				expect(res).toHaveProperty("id");
+				expect(typeof res.id).toBe("string");
+				expect(Number(res.id)).toBeGreaterThan(0);
+			},
+			...normalTests,
+		};
+	},
+);

package/src/test/adapter-factory/profile-additional-fields.ts

@@ -0,0 +1,84 @@
+import { createTestSuite } from "@better-auth/test-utils/adapter";
+import { expect } from "vitest";
+import { getNormalTestSuiteTests } from "./basic.js";
+import {
+	AUTH_FLOW_DEFAULT_BETTER_AUTH_OPTIONS,
+	getAuthFlowSuiteTests,
+} from "./auth-flow.js";
+
+export const ADDITIONAL_FIELDS_NORMAL_TESTS = [
+	"deleteMany - should delete many models with numeric values",
+	"findMany - should find many models with sortBy",
+	"findMany - should find many models with sortBy and limit",
+	"findMany - should find many with join and sortBy",
+	"findOne - should find a model with additional fields",
+] as const;
+
+export const ADDITIONAL_FIELDS_AUTH_FLOW_TEST =
+	"should sign up with additional fields" as const;
+
+const pickTests = (
+	tests: ReturnType<typeof getNormalTestSuiteTests>,
+	testNames: readonly string[],
+) =>
+	Object.fromEntries(
+		Object.entries(tests).filter(([testName]) => testNames.includes(testName)),
+	);
+
+const omitTests = (
+	tests: ReturnType<typeof getNormalTestSuiteTests>,
+	testNames: readonly string[],
+) =>
+	Object.fromEntries(
+		Object.entries(tests).filter(([testName]) => !testNames.includes(testName)),
+	);
+
+export const coreNormalTestSuite = createTestSuite(
+	"normal",
+	{},
+	(helpers, debugTools) => {
+		const tests = getNormalTestSuiteTests(helpers, debugTools);
+		return {
+			"init - tests": async () => {
+				const opts = helpers.getBetterAuthOptions();
+				expect(opts.advanced?.database?.generateId !== "serial").toBeTruthy();
+			},
+			...omitTests(tests, ADDITIONAL_FIELDS_NORMAL_TESTS),
+		};
+	},
+);
+
+export const additionalFieldsNormalTestSuite = createTestSuite(
+	"normal-additional-fields",
+	{},
+	(helpers, debugTools) => {
+		const tests = getNormalTestSuiteTests(helpers, debugTools);
+		return pickTests(tests, ADDITIONAL_FIELDS_NORMAL_TESTS);
+	},
+);
+
+export const coreAuthFlowTestSuite = createTestSuite(
+	"auth-flow",
+	{
+		defaultBetterAuthOptions: AUTH_FLOW_DEFAULT_BETTER_AUTH_OPTIONS,
+	},
+	(helpers) => {
+		const tests = getAuthFlowSuiteTests(helpers);
+		const { [ADDITIONAL_FIELDS_AUTH_FLOW_TEST]: _skip, ...remaining } = tests;
+		return remaining;
+	},
+);
+
+export const additionalFieldsAuthFlowTestSuite = createTestSuite(
+	"auth-flow-additional-fields",
+	{
+		defaultBetterAuthOptions: AUTH_FLOW_DEFAULT_BETTER_AUTH_OPTIONS,
+	},
+	(helpers) => {
+		const tests = getAuthFlowSuiteTests(helpers);
+		return {
+			[ADDITIONAL_FIELDS_AUTH_FLOW_TEST]:
+				tests[ADDITIONAL_FIELDS_AUTH_FLOW_TEST],
+		};
+	},
+);

package/src/test/adapter-factory/profile-plugin-table.ts

@@ -0,0 +1,37 @@
+import { createTestSuite } from "@better-auth/test-utils/adapter";
+import { getNormalTestSuiteTests } from "./basic.js";
+
+export const PLUGIN_TABLE_NORMAL_TESTS = [
+  "create - should apply default values to fields",
+  "create - should return null for nullable foreign keys",
+  "create - should support arrays",
+  "create - should support json",
+  "findMany - should find many with both one-to-one and one-to-many joins",
+  "findMany - should find many with one-to-one join",
+  "findMany - should handle mixed joins correctly when some are missing",
+  "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",
+  "findOne - should not apply defaultValue if value not found",
+  "findOne - should return an object for one-to-one joins",
+  "findOne - should return null for one-to-one join when joined record doesn't exist",
+  "findOne - should select fields with one-to-one join",
+  "findOne - should work with both one-to-one and one-to-many joins",
+] as const;
+
+const pickTests = (
+  tests: ReturnType<typeof getNormalTestSuiteTests>,
+  testNames: readonly string[],
+) =>
+  Object.fromEntries(
+    Object.entries(tests).filter(([testName]) => testNames.includes(testName)),
+  );
+
+export const pluginTableNormalTestSuite = createTestSuite(
+  "normal-plugin-table",
+  {},
+  (helpers, debugTools) => {
+    const tests = getNormalTestSuiteTests(helpers, debugTools);
+    return pickTests(tests, PLUGIN_TABLE_NORMAL_TESTS);
+  },
+);

package/src/test/adapter-factory/profile-rename-joins.ts

@@ -0,0 +1,67 @@
+import { createTestSuite } from "@better-auth/test-utils/adapter";
+import { getNormalTestSuiteTests } from "./basic.js";
+
+const pickTests = (
+  tests: ReturnType<typeof getNormalTestSuiteTests>,
+  testNames: readonly string[],
+) =>
+  Object.fromEntries(
+    Object.entries(tests).filter(([testName]) => testNames.includes(testName)),
+  );
+
+export const RENAME_FIELD_AND_JOIN_TESTS = [
+  "findOne - should find a model with modified field name",
+  "findOne - should join a model with modified field name",
+  "findOne - should return null for failed base model lookup that has joins",
+] as const;
+
+export const RENAME_MODEL_USER_CUSTOM_TEST =
+  "findOne - should find a model with modified model name" as const;
+
+export const RENAME_MODEL_USER_TABLE_TEST =
+  "findOne - backwards join with modified field name (session base, users-table join)" as const;
+
+export const MULTI_JOINS_MISSING_ROWS_TEST =
+  "findOne - multiple joins should return result even when some joined tables have no matching rows" as const;
+
+export const renameFieldAndJoinTestSuite = createTestSuite(
+  "normal-rename-field-and-join",
+  {},
+  (helpers, debugTools) => {
+    const tests = getNormalTestSuiteTests(helpers, debugTools);
+    return pickTests(tests, RENAME_FIELD_AND_JOIN_TESTS);
+  },
+);
+
+export const renameModelUserCustomTestSuite = createTestSuite(
+  "normal-rename-model-user-custom",
+  {},
+  (helpers, debugTools) => {
+    const tests = getNormalTestSuiteTests(helpers, debugTools);
+    return {
+      [RENAME_MODEL_USER_CUSTOM_TEST]: tests[RENAME_MODEL_USER_CUSTOM_TEST],
+    };
+  },
+);
+
+export const renameModelUserTableTestSuite = createTestSuite(
+  "normal-rename-model-user-table",
+  {},
+  (helpers, debugTools) => {
+    const tests = getNormalTestSuiteTests(helpers, debugTools);
+    return {
+      [RENAME_MODEL_USER_TABLE_TEST]: tests[RENAME_MODEL_USER_TABLE_TEST],
+    };
+  },
+);
+
+export const multiJoinsMissingRowsTestSuite = createTestSuite(
+  "normal-multi-joins-missing-rows",
+  {},
+  (helpers, debugTools) => {
+    const tests = getNormalTestSuiteTests(helpers, debugTools);
+    return {
+      [MULTI_JOINS_MISSING_ROWS_TEST]: tests[MULTI_JOINS_MISSING_ROWS_TEST],
+    };
+  },
+);

package/src/test/adapter-factory/transactions.ts

@@ -0,0 +1,38 @@
+import { createTestSuite } from "@better-auth/test-utils/adapter";
+import type { User } from "better-auth/db";
+import { expect } from "vitest";
+
+/**
+ * This test suite tests the transaction functionality of the adapter.
+ */
+export const transactionsTestSuite = createTestSuite(
+	"transactions",
+	{},
+	({ adapter, generate, hardCleanup }) => ({
+		"transaction - should rollback failing transaction": async ({ skip }) => {
+			const isEnabled = adapter.options?.adapterConfig.transaction;
+			if (!isEnabled) {
+				skip(
+					`Skipping test: ${adapter.options?.adapterConfig.adapterName} does not support transactions`,
+				);
+				return;
+			}
+
+			const user1 = await generate("user");
+			await expect(
+				adapter.transaction(async (tx) => {
+					await tx.create({ model: "user", data: user1, forceAllowId: true });
+					const users = await tx.findMany({ model: "user" });
+					expect(users).toHaveLength(1);
+					throw new Error("Simulated failure");
+				}),
+			).rejects.toThrow("Simulated failure");
+			const result = await adapter.findMany<User>({
+				model: "user",
+			});
+			//Transactions made rows are unable to be automatically cleaned up, so we need to clean them up manually
+			await hardCleanup();
+			expect(result.length).toBe(0);
+		},
+	}),
+);

package/src/test/adapter-factory/uuid.ts

@@ -0,0 +1,67 @@
+import type { User } from "@better-auth/core/db";
+import { createTestSuite } from "@better-auth/test-utils/adapter";
+import { expect } from "vitest";
+import { getNormalTestSuiteTests } from "./basic.js";
+
+export const uuidTestSuite = createTestSuite(
+	"uuid",
+	{
+		defaultBetterAuthOptions: {
+			advanced: {
+				database: {
+					generateId: "uuid",
+				},
+			},
+		},
+		prefixTests: "uuid",
+		alwaysMigrate: true,
+		// This is here to overwrite `generateId` functions to generate UUIDs instead of the default.
+		// Since existing tests often use generated IDs as well as `forceAllowId` to be true, this is needed to ensure the tests pass.
+		customIdGenerator() {
+			return crypto.randomUUID();
+		},
+	},
+	(helpers) => {
+		const { "create - should use generateId if provided": _, ...normalTests } =
+			getNormalTestSuiteTests(helpers);
+		return {
+			"init - tests": async () => {
+				const opts = helpers.getBetterAuthOptions();
+				expect(opts.advanced?.database?.generateId === "uuid").toBe(true);
+			},
+			"create - should return a uuid": async () => {
+				const user = await helpers.generate("user");
+				const res = await helpers.adapter.create<User>({
+					model: "user",
+					data: {
+						...user,
+						//@ts-expect-error - remove id from `user`
+						id: undefined,
+					},
+				});
+				expect(res).toHaveProperty("id");
+				expect(typeof res.id).toBe("string");
+				const uuidRegex =
+					/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+				expect(res.id).toMatch(uuidRegex);
+			},
+			"findOne - should find a model using a uuid": async () => {
+				const { id: _, ...user } = await helpers.generate("user");
+				const res = await helpers.adapter.create<User>({
+					model: "user",
+					data: user,
+				});
+
+				const result = await helpers.adapter.findOne<User>({
+					model: "user",
+					where: [{ field: "id", value: res.id }],
+				});
+				const uuidRegex =
+					/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+				expect(result?.id).toMatch(uuidRegex);
+				expect(result).toEqual(res);
+			},
+			...normalTests,
+		};
+	},
+);

package/src/utils/index.ts

@@ -1,6 +1,4 @@
 import { betterFetch } from "@better-fetch/fetch";
-import type { Auth } from "better-auth";
-import type { betterAuth } from "better-auth/minimal";
 import { getSessionCookie } from "better-auth/cookies";
 import type {
   AuthProvider,
@@ -15,9 +13,33 @@ import { JWT_COOKIE_NAME } from "../plugins/convex/index.js";
 import * as jose from "jose";
 import type { Jwk } from "better-auth/plugins/jwt";
 
+type TrustedOriginsOption =
+  | (string | null | undefined)[]
+  | ((
+      request?: Request
+    ) =>
+      | (string | null | undefined)[]
+      | Promise<(string | null | undefined)[]>);
+
+type RegisterableAuth = {
+  handler: (request: Request) => Promise<Response>;
+  options: {
+    baseURL?: string;
+    basePath?: string;
+    trustedOrigins?: TrustedOriginsOption;
+    [key: string]: unknown;
+  };
+  $context: Promise<{
+    options: {
+      trustedOrigins?: TrustedOriginsOption;
+      [key: string]: unknown;
+    };
+  }>;
+};
+
 export type CreateAuth<
   DataModel extends GenericDataModel,
-  A extends ReturnType<typeof betterAuth> = Auth,
+  A extends RegisterableAuth = RegisterableAuth,
 > = (ctx: GenericCtx<DataModel>) => A;
 
 export type EventFunction<T extends DefaultFunctionArgs> = FunctionReference<